Merge pull request opentripplanner#7200 from HSLdevcom/canceled-trips-mode-filter

Add modes filter and totalCount to the canceled trips query in the GTFS API

Author: optionsome

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

@@ -30,6 +30,7 @@
 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.CanceledTripsFilterMapper;
 import org.opentripplanner.apis.gtfs.mapping.routerequest.LegacyRouteRequestMapper;
 import org.opentripplanner.apis.gtfs.mapping.routerequest.RouteRequestMapper;
 import org.opentripplanner.apis.gtfs.support.filter.PatternByDateFilterUtil;
@@ -38,6 +39,8 @@
 import org.opentripplanner.ext.fares.model.FareRuleSet;
 import org.opentripplanner.ext.fares.service.gtfs.GtfsFaresService;
 import org.opentripplanner.ext.fares.service.gtfs.v1.DefaultFareService;
+import org.opentripplanner.framework.graphql.CountedConnection;
+import org.opentripplanner.framework.graphql.SimpleCountedListConnection;
 import org.opentripplanner.graph_builder.issue.api.DataImportIssueStore;
 import org.opentripplanner.gtfs.mapping.DirectionMapper;
 import org.opentripplanner.model.TripTimeOnDate;
@@ -818,10 +821,11 @@ public DataFetcher<Iterable<Trip>> trips() {
   }
 
   @Override
-  public DataFetcher<Connection<TripOnServiceDate>> canceledTrips() {
+  public DataFetcher<CountedConnection<TripOnServiceDate>> canceledTrips() {
     return environment -> {
-      var trips = getTransitService(environment).listCanceledTrips();
-      return new SimpleListConnection<>(trips).get(environment);
+      var request = CanceledTripsFilterMapper.mapToTripOnServiceDateRequest(environment);
+      var trips = getTransitService(environment).findCanceledTrips(request);
+      return new SimpleCountedListConnection<>(trips).get(environment);
     };
   }
 

application/src/main/java/org/opentripplanner/apis/gtfs/generated/GraphQLDataFetchers.java

@@ -34,6 +34,7 @@
 import org.opentripplanner.apis.gtfs.model.TripOccupancy;
 import org.opentripplanner.ext.fares.model.FareRuleSet;
 import org.opentripplanner.ext.ridehailing.model.RideEstimate;
+import org.opentripplanner.framework.graphql.CountedConnection;
 import org.opentripplanner.model.StopTimesInPattern;
 import org.opentripplanner.model.SystemNotice;
 import org.opentripplanner.model.TripTimeOnDate;
@@ -903,7 +904,7 @@ public interface GraphQLQueryType {
 
     public DataFetcher<Iterable<VehicleRentalPlace>> bikeRentalStations();
 
-    public DataFetcher<Connection<TripOnServiceDate>> canceledTrips();
+    public DataFetcher<CountedConnection<TripOnServiceDate>> canceledTrips();
 
     public DataFetcher<Iterable<TripTimeOnDate>> cancelledTripTimes();
 
@@ -1425,6 +1426,8 @@ public interface GraphQLTripOnServiceDateConnection {
     public DataFetcher<Iterable<Edge<TripOnServiceDate>>> edges();
 
     public DataFetcher<Object> pageInfo();
+
+    public DataFetcher<Integer> totalCount();
   }
 
   /**

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

@@ -497,6 +497,69 @@ public void setGraphQLWaitReluctance(Double waitReluctance) {
     }
   }
 
+  public static class GraphQLCanceledTripsFilterInput {
+
+    private List<GraphQLCanceledTripsFilterSelectInput> exclude;
+    private List<GraphQLCanceledTripsFilterSelectInput> include;
+
+    public GraphQLCanceledTripsFilterInput(Map<String, Object> args) {
+      if (args != null) {
+        if (args.get("exclude") != null) {
+          this.exclude = ((List<Map<String, Object>>) args.get("exclude")).stream()
+            .map(o -> o == null ? null : new GraphQLCanceledTripsFilterSelectInput(o))
+            .collect(Collectors.toList());
+        }
+        if (args.get("include") != null) {
+          this.include = ((List<Map<String, Object>>) args.get("include")).stream()
+            .map(o -> o == null ? null : new GraphQLCanceledTripsFilterSelectInput(o))
+            .collect(Collectors.toList());
+        }
+      }
+    }
+
+    public List<GraphQLCanceledTripsFilterSelectInput> getGraphQLExclude() {
+      return this.exclude;
+    }
+
+    public List<GraphQLCanceledTripsFilterSelectInput> getGraphQLInclude() {
+      return this.include;
+    }
+
+    public void setGraphQLExclude(List<GraphQLCanceledTripsFilterSelectInput> exclude) {
+      this.exclude = exclude;
+    }
+
+    public void setGraphQLInclude(List<GraphQLCanceledTripsFilterSelectInput> include) {
+      this.include = include;
+    }
+  }
+
+  public static class GraphQLCanceledTripsFilterSelectInput {
+
+    private List<GraphQLTransitMode> modes;
+
+    public GraphQLCanceledTripsFilterSelectInput(Map<String, Object> args) {
+      if (args != null) {
+        if (args.get("modes") != null) {
+          this.modes = ((List<Object>) args.get("modes")).stream()
+            .map(item ->
+              item instanceof GraphQLTransitMode ? item : GraphQLTransitMode.valueOf((String) item)
+            )
+            .map(GraphQLTransitMode.class::cast)
+            .collect(Collectors.toList());
+        }
+      }
+    }
+
+    public List<GraphQLTransitMode> getGraphQLModes() {
+      return this.modes;
+    }
+
+    public void setGraphQLModes(List<GraphQLTransitMode> modes) {
+      this.modes = modes;
+    }
+  }
+
   public static class GraphQLCarParkNameArgs {
 
     private String language;
@@ -2590,13 +2653,17 @@ public static class GraphQLQueryTypeCanceledTripsArgs {
 
     private String after;
     private String before;
+    private GraphQLCanceledTripsFilterInput filters;
     private Integer first;
     private Integer last;
 
     public GraphQLQueryTypeCanceledTripsArgs(Map<String, Object> args) {
       if (args != null) {
         this.after = (String) args.get("after");
         this.before = (String) args.get("before");
+        this.filters = new GraphQLCanceledTripsFilterInput(
+          (Map<String, Object>) args.get("filters")
+        );
         this.first = (Integer) args.get("first");
         this.last = (Integer) args.get("last");
       }
@@ -2610,6 +2677,10 @@ public String getGraphQLBefore() {
       return this.before;
     }
 
+    public GraphQLCanceledTripsFilterInput getGraphQLFilters() {
+      return this.filters;
+    }
+
     public Integer getGraphQLFirst() {
       return this.first;
     }
@@ -2626,6 +2697,10 @@ public void setGraphQLBefore(String before) {
       this.before = before;
     }
 
+    public void setGraphQLFilters(GraphQLCanceledTripsFilterInput filters) {
+      this.filters = filters;
+    }
+
     public void setGraphQLFirst(Integer first) {
       this.first = first;
     }

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

@@ -61,7 +61,7 @@ config:
     Coordinates: org.locationtech.jts.geom.Coordinate#Coordinate
     StopCall: org.opentripplanner.model.TripTimeOnDate#TripTimeOnDate
     TripOnServiceDate: org.opentripplanner.transit.model.timetable.TripOnServiceDate#TripOnServiceDate
-    TripOnServiceDateConnection: graphql.relay.Connection#Connection<TripOnServiceDate>
+    TripOnServiceDateConnection: org.opentripplanner.framework.graphql.CountedConnection#CountedConnection<TripOnServiceDate>
     TripOnServiceDateEdge: graphql.relay.Edge#Edge<TripOnServiceDate>
     debugOutput: org.opentripplanner.api.resource.DebugOutput#DebugOutput
     DepartureRow: org.opentripplanner.routing.graphfinder.PatternAtStop#PatternAtStop

application/src/main/java/org/opentripplanner/apis/gtfs/mapping/CanceledTripsFilterMapper.java

@@ -0,0 +1,64 @@
+package org.opentripplanner.apis.gtfs.mapping;
+
+import graphql.schema.DataFetchingEnvironment;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.Nullable;
+import org.opentripplanner.apis.gtfs.generated.GraphQLTypes;
+import org.opentripplanner.transit.api.model.FilterValues;
+import org.opentripplanner.transit.api.request.TripOnServiceDateRequest;
+import org.opentripplanner.transit.model.basic.TransitMode;
+import org.opentripplanner.utils.collection.CollectionUtils;
+
+public class CanceledTripsFilterMapper {
+
+  public static TripOnServiceDateRequest mapToTripOnServiceDateRequest(
+    DataFetchingEnvironment env
+  ) {
+    var filter = new GraphQLTypes.GraphQLQueryTypeCanceledTripsArgs(
+      env.getArguments()
+    ).getGraphQLFilters();
+    var includes = filter.getGraphQLInclude();
+    var excludes = filter.getGraphQLExclude();
+    CollectionUtils.requireNullOrNonEmpty(includes, "filters.include");
+    CollectionUtils.requireNullOrNonEmpty(excludes, "filters.exclude");
+    var modesToInclude = CanceledTripsFilterMapper.toTransitModes(includes);
+    var modesToExclude = CanceledTripsFilterMapper.toTransitModes(excludes);
+    var modesToIncludeFilter = FilterValues.ofNullIsEverything("modesToInclude", modesToInclude);
+    var modesToExcludeFilter = FilterValues.ofNullIsEverything("modesToExclude", modesToExclude);
+    return TripOnServiceDateRequest.of()
+      .withIncludeModes(modesToIncludeFilter)
+      .withExcludeModes(modesToExcludeFilter)
+      .build();
+  }
+
+  @Nullable
+  private static Set<TransitMode> toTransitModes(
+    List<GraphQLTypes.GraphQLCanceledTripsFilterSelectInput> inputs
+  ) {
+    if (inputs == null) {
+      return null;
+    }
+    if (
+      inputs
+        .stream()
+        .anyMatch(input -> input.getGraphQLModes() != null && input.getGraphQLModes().isEmpty())
+    ) {
+      throw new IllegalArgumentException(
+        "Mode filter must be either null or have at least one entry."
+      );
+    }
+    return inputs
+      .stream()
+      .flatMap(include -> {
+        var modes = include.getGraphQLModes();
+        if (modes == null) {
+          return Stream.of();
+        }
+        return include.getGraphQLModes().stream().map(TransitModeMapper::map);
+      })
+      .collect(Collectors.toSet());
+  }
+}

application/src/main/java/org/opentripplanner/apis/transmodel/model/timetable/DatedServiceJourneyQuery.java

@@ -122,16 +122,17 @@ public GraphQLFieldDefinition createQuery(GraphQLOutputType datedServiceJourneyT
         );
 
         TripOnServiceDateRequestBuilder tripOnServiceDateRequestBuilder =
-          TripOnServiceDateRequest.of(operatingDays)
-            .withAgencies(authorities)
-            .withRoutes(lines)
-            .withServiceJourneys(serviceJourneys)
-            .withReplacementFor(replacementFor);
+          TripOnServiceDateRequest.of()
+            .withIncludeServiceDates(operatingDays)
+            .withIncludeAgencies(authorities)
+            .withIncludeRoutes(lines)
+            .withIncludeServiceJourneys(serviceJourneys)
+            .withIncludeReplacementFor(replacementFor);
 
         tripOnServiceDateRequestBuilder =
-          tripOnServiceDateRequestBuilder.withNetexInternalPlanningCodes(privateCodes);
+          tripOnServiceDateRequestBuilder.withIncludeNetexInternalPlanningCodes(privateCodes);
 
-        tripOnServiceDateRequestBuilder = tripOnServiceDateRequestBuilder.withAlterations(
+        tripOnServiceDateRequestBuilder = tripOnServiceDateRequestBuilder.withIncludeAlterations(
           alterations
         );
 

application/src/main/java/org/opentripplanner/framework/graphql/CountedConnection.java

@@ -0,0 +1,14 @@
+package org.opentripplanner.framework.graphql;
+
+import graphql.relay.Connection;
+
+/**
+ * This interface extends the standard GraphQL Connection interface with a method to get the total
+ * number of items available in the underlying collection.
+ */
+public interface CountedConnection<T> extends Connection<T> {
+  /**
+   * The total number of items available in the underlying collection
+   */
+  int getTotalCount();
+}

application/src/main/java/org/opentripplanner/framework/graphql/DefaultCountedConnection.java

@@ -0,0 +1,60 @@
+package org.opentripplanner.framework.graphql;
+
+import graphql.relay.DefaultConnection;
+import graphql.relay.Edge;
+import graphql.relay.PageInfo;
+import java.util.List;
+import java.util.Objects;
+import org.opentripplanner.utils.tostring.ToStringBuilder;
+
+/**
+ * This class extends the {@link DefaultConnection} with a somewhat standard {@code totalCount}
+ * field.
+ */
+public class DefaultCountedConnection<T>
+  extends DefaultConnection<T>
+  implements CountedConnection<T> {
+
+  private final Integer totalCount;
+
+  public DefaultCountedConnection(List<Edge<T>> edges, PageInfo pageInfo, Integer totalCount) {
+    super(edges, pageInfo);
+    this.totalCount = totalCount;
+  }
+
+  @Override
+  public int getTotalCount() {
+    return totalCount;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    DefaultCountedConnection<?> that = (DefaultCountedConnection<?>) o;
+
+    return (
+      Objects.equals(getEdges(), that.getEdges()) &&
+      Objects.equals(getPageInfo(), that.getPageInfo()) &&
+      totalCount.equals(that.totalCount)
+    );
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(getEdges(), getPageInfo(), totalCount);
+  }
+
+  @Override
+  public String toString() {
+    return ToStringBuilder.of(getClass())
+      .addColSize("edges", getEdges())
+      .addObj("pageInfo", getPageInfo())
+      .addNum("totalCount", totalCount)
+      .toString();
+  }
+}

application/src/main/java/org/opentripplanner/framework/graphql/SimpleCountedListConnection.java

@@ -0,0 +1,33 @@
+package org.opentripplanner.framework.graphql;
+
+import graphql.TrivialDataFetcher;
+import graphql.relay.SimpleListConnection;
+import graphql.schema.DataFetcher;
+import graphql.schema.DataFetchingEnvironment;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * This class is a version of the {@link SimpleListConnection} that returns a
+ * {@link CountedConnection}.
+ */
+public class SimpleCountedListConnection<T>
+  implements DataFetcher<CountedConnection<T>>, TrivialDataFetcher<CountedConnection<T>> {
+
+  private final List<T> data;
+
+  public SimpleCountedListConnection(List<T> data) {
+    this.data = Objects.requireNonNull(data);
+  }
+
+  @Override
+  public CountedConnection<T> get(DataFetchingEnvironment environment) {
+    var simpleListConnection = new SimpleListConnection<>(data);
+    var connection = simpleListConnection.get(environment);
+    return new DefaultCountedConnection<>(
+      connection.getEdges(),
+      connection.getPageInfo(),
+      data.size()
+    );
+  }
+}