Esempio n. 1
0
  public static List<WrappedGTFSEntity<Pattern>> fromRoute(DataFetchingEnvironment env) {
    WrappedGTFSEntity<Route> route = (WrappedGTFSEntity<Route>) env.getSource();
    FeedSource fs = ApiMain.getFeedSource(route.feedUniqueId);
    if (fs == null) return null;

    List<String> stopIds = env.getArgument("stop_id");
    List<String> patternId = env.getArgument("pattern_id");
    Long limit = env.getArgument("limit");

    List<WrappedGTFSEntity<Pattern>> patterns =
        fs.feed
            .patterns
            .values()
            .stream()
            .filter(p -> p.route_id.equals(route.entity.route_id))
            .map(p -> new WrappedGTFSEntity<>(fs.id, p))
            .collect(Collectors.toList());
    if (patternId != null) {
      patterns
          .stream()
          .filter(p -> patternId.contains(p.entity.pattern_id))
          .collect(Collectors.toList());
    }
    if (stopIds != null) {
      patterns
          .stream()
          .filter(
              p ->
                  !Collections.disjoint(
                      p.entity.orderedStops,
                      stopIds)) // disjoint returns true if no elements in common
          .collect(Collectors.toList());
    }
    if (limit != null) {
      return patterns.stream().limit(limit).collect(Collectors.toList());
    }
    return patterns;
  }
Esempio n. 2
0
  public static List<WrappedGTFSEntity<Pattern>> apex(DataFetchingEnvironment env) {
    Collection<FeedSource> feeds;

    List<String> feedId = (List<String>) env.getArgument("feed_id");
    feeds = ApiMain.getFeedSources(feedId);
    Map<String, Object> args = env.getArguments();
    List<WrappedGTFSEntity<Pattern>> patterns = new ArrayList<>();

    for (FeedSource fs : feeds) {
      if (env.getArgument("pattern_id") != null) {
        List<String> patternId = (List<String>) env.getArgument("pattern_id");
        patternId
            .stream()
            .filter(fs.feed.patterns::containsKey)
            .map(fs.feed.patterns::get)
            .map(pattern -> new WrappedGTFSEntity(fs.id, pattern))
            .forEach(patterns::add);
      } else if (env.getArgument("route_id") != null) {
        List<String> routeId = (List<String>) env.getArgument("route_id");
        fs.feed
            .patterns
            .values()
            .stream()
            .filter(p -> routeId.contains(p.route_id))
            .map(pattern -> new WrappedGTFSEntity(fs.id, pattern))
            .forEach(patterns::add);
      }
      // get patterns by lat/lon/radius
      else if (argumentDefined(env, "lat") && argumentDefined(env, "lon")) {
        Double lat = (Double) args.get("lat");
        Double lon = (Double) args.get("lon");
        Double radius = args.get("radius") == null ? DEFAULT_RADIUS : (Double) args.get("radius");
        Coordinate latLng = new Coordinate(lon, lat);
        Envelope searchEnvelope = GeomUtil.getBoundingBox(latLng, radius);

        List<Pattern> results = fs.routeIndex.query(searchEnvelope);
        results
            .stream()
            .map(pattern -> new WrappedGTFSEntity(fs.id, pattern))
            .forEach(patterns::add);
      }
      // get patterns by bounding box
      else if (argumentDefined(env, "min_lat")
          && argumentDefined(env, "max_lat")
          && argumentDefined(env, "min_lon")
          && argumentDefined(env, "max_lon")) {
        Coordinate maxCoordinate =
            new Coordinate((Double) args.get("max_lon"), (Double) args.get("max_lat"));
        Coordinate minCoordinate =
            new Coordinate((Double) args.get("min_lon"), (Double) args.get("min_lat"));
        Envelope searchEnvelope = new Envelope(maxCoordinate, minCoordinate);

        List<Pattern> results = (List<Pattern>) fs.routeIndex.query(searchEnvelope);
        results
            .stream()
            .filter(p -> p != null)
            .map(pattern -> new WrappedGTFSEntity(fs.id, pattern))
            .forEach(patterns::add);
      }
    }

    return patterns;
  }