public static void main(String[] args) throws SQLException {
    // open database
    Connection conn = DriverManager.getConnection("jdbc:h2:./main");
    createTables(conn);

    // serve external files
    Spark.externalStaticFileLocation("public");
    Spark.init();

    // insert test data
    if (selectCountries(conn).size() == 0) {
      insertCountry(conn, "United States", "US");
      insertCountry(conn, "Canada", "CA");
      insertCountry(conn, "Mexico", "MX");
    }

    // create routes for AJAX
    Spark.get(
        "/get-countries",
        ((request, response) -> {
          JsonSerializer serializer = new JsonSerializer();
          String json = serializer.serialize(selectCountries(conn));
          return json;
        }));
    Spark.get(
        "/get-country",
        ((request, response) -> {
          String id = request.queryParams("id");
          try {
            int idNum = Integer.valueOf(id);
            JsonSerializer serializer = new JsonSerializer();
            String json = serializer.serialize(selectCountry(conn, idNum));
            return json;
          } catch (Exception e) {

          }
          return "";
        }));
    Spark.post(
        "/add-country",
        ((request, response) -> {
          String name = request.queryParams("name");
          String abbrev = request.queryParams("abbrev");
          if (name == null || abbrev == null) {
            Spark.halt(403);
          }
          insertCountry(conn, name, abbrev);
          return "";
        }));
  }
  public static void main(String[] args) {

    final Configuration configuration = new Configuration(Configuration.VERSION_2_3_23);
    configuration.setClassForTemplateLoading(HelloWorldFreemarkerStyle.class, "/");

    get(
        "/",
        (request, response) -> {
          StringWriter writer = new StringWriter();
          try {
            Template helloTemplate = configuration.getTemplate("hello.ftl");

            Map<String, Object> helloMap = new HashMap<>();
            helloMap.put("name", "Freemarker");

            helloTemplate.process(helloMap, writer);
          } catch (Exception e) {
            halt(500);
            e.printStackTrace();
          }
          return writer;
        });
  }
Пример #3
0
  @SuppressWarnings("unchecked")
  private void setupRoutes() {

    before(
        (req, res) -> {
          log.info("Path is: " + req.pathInfo());
          CallingContext ctx = ctxs.get(req.session().id());
          if (ctx == null) {
            // check x-api-key header
            String apiKey = req.headers("x-api-key");
            if (StringUtils.isNotBlank(apiKey)) {
              ctx = Kernel.INSTANCE.loadContext(APP_KEY, apiKey);
              if (ctx == null) {
                String msg = String.format("Invalid apiKey [%s] for app [%s]", apiKey, APP_KEY);
                log.warn(msg);
                halt(401, msg);
              }
              String id = req.session(true).id();
              ctxs.put(id, ctx);
            } else {
              log.warn("x-api-key header not found, rejecting...");
              halt(401, "Please provide 'x-api-key' header to access this API");
            }
          }
        });

    post(
        "/doc/:authority",
        (req, res) -> {
          log.info(req.body());
          Map<String, Object> data = JacksonUtil.getMapFromJson(req.body());
          String authority = req.params(":authority");
          String config = (String) data.get("config");
          CallingContext ctx = getContext(req);
          if (Kernel.getDoc().docRepoExists(ctx, authority)) {
            halt(409, String.format("Repo [%s] already exists", authority));
          }
          Kernel.getDoc().createDocRepo(ctx, authority, config);
          return new RaptureURI(authority, Scheme.DOCUMENT).toString();
        });

    get(
        "/doc/*",
        (req, res) -> {
          String meta = req.queryParams("meta");
          if (StringUtils.isNotBlank(meta)) {
            return Kernel.getDoc().getDocAndMeta(getContext(req), getDocUriParam(req));
          }
          return Kernel.getDoc().getDoc(getContext(req), getDocUriParam(req));
        });

    put(
        "/doc/*",
        (req, res) -> {
          return Kernel.getDoc().putDoc(getContext(req), getDocUriParam(req), req.body());
        });

    delete(
        "/doc/:authority",
        (req, res) -> {
          Kernel.getDoc().deleteDocRepo(getContext(req), req.params(":authority"));
          return true;
        });

    delete(
        "/doc/*",
        (req, res) -> {
          return Kernel.getDoc().deleteDoc(getContext(req), getDocUriParam(req));
        });

    post(
        "/blob/:authority",
        (req, res) -> {
          log.info(req.body());
          Map<String, Object> data = JacksonUtil.getMapFromJson(req.body());
          String authority = req.params(":authority");
          String config = (String) data.get("config");
          String metaConfig = (String) data.get("metaConfig");
          CallingContext ctx = getContext(req);
          if (Kernel.getBlob().blobRepoExists(ctx, authority)) {
            halt(409, String.format("Repo [%s] already exists", authority));
          }
          Kernel.getBlob().createBlobRepo(ctx, authority, config, metaConfig);
          return new RaptureURI(authority, Scheme.BLOB).toString();
        });

    get(
        "/blob/*",
        (req, res) -> {
          return Kernel.getBlob().getBlob(getContext(req), getBlobUriParam(req));
        },
        json());

    put(
        "/blob/*",
        (req, res) -> {
          String uri = getBlobUriParam(req);
          Kernel.getBlob().putBlob(getContext(req), uri, req.bodyAsBytes(), req.contentType());
          return uri;
        });

    delete(
        "/blob/:authority",
        (req, res) -> {
          Kernel.getBlob().deleteBlobRepo(getContext(req), req.params(":authority"));
          return true;
        });

    delete(
        "/blob/*",
        (req, res) -> {
          Kernel.getBlob().deleteBlob(getContext(req), getBlobUriParam(req));
          return true;
        });

    post(
        "/series/:authority",
        (req, res) -> {
          log.info(req.body());
          Map<String, Object> data = JacksonUtil.getMapFromJson(req.body());
          String authority = req.params(":authority");
          String config = (String) data.get("config");
          CallingContext ctx = getContext(req);
          if (Kernel.getSeries().seriesRepoExists(ctx, authority)) {
            halt(409, String.format("Repo [%s] already exists", authority));
          }
          Kernel.getSeries().createSeriesRepo(ctx, authority, config);
          return new RaptureURI(authority, Scheme.SERIES).toString();
        });

    get(
        "/series/*",
        (req, res) -> {
          return Kernel.getSeries().getPoints(getContext(req), getSeriesUriParam(req));
        },
        json());

    put(
        "/series/*",
        (req, res) -> {
          String uri = getSeriesUriParam(req);
          Map<String, Object> data = JacksonUtil.getMapFromJson(req.body());
          List<String> keys = (List<String>) data.get("keys");
          List<Object> values = (List<Object>) data.get("values");
          if (!values.isEmpty()) {
            Object obj = values.get(0);
            if (obj instanceof Long) {
              Kernel.getSeries()
                  .addLongsToSeries(getContext(req), uri, keys, (List<Long>) (List<?>) values);
            } else if (obj instanceof String) {
              Kernel.getSeries()
                  .addStringsToSeries(getContext(req), uri, keys, (List<String>) (List<?>) values);
            } else if (obj instanceof Double) {
              Kernel.getSeries()
                  .addDoublesToSeries(getContext(req), uri, keys, (List<Double>) (List<?>) values);
            } else {
              halt(400, "Unknown type in values parameter");
            }
          }
          return uri;
        });

    delete(
        "/series/:authority",
        (req, res) -> {
          Kernel.getSeries().deleteSeriesRepo(getContext(req), req.params(":authority"));
          return true;
        });

    delete(
        "/series/*",
        (req, res) -> {
          Kernel.getSeries().deleteSeries(getContext(req), getSeriesUriParam(req));
          return true;
        });

    post(
        "/workorder/*",
        (req, res) -> {
          Map<String, String> params = new HashMap<>();
          String body = req.body();
          if (StringUtils.isNotBlank(body)) {
            Map<String, Object> data = JacksonUtil.getMapFromJson(body);
            params = (Map<String, String>) data.get("params");
          }
          return Kernel.getDecision()
              .createWorkOrder(getContext(req), getWorkorderUriParam(req), params);
        });
  }
  public static void main(String[] args) {

    // serve static files from /www in resources
    staticFileLocation("/www");

    // setup the database model
    Sql2o sql2o = new Sql2o("jdbc:h2:~/test", "sa", "");
    Sql2oModel model = new Sql2oModel(sql2o);

    // url /hello
    // simple response return
    get("/hello", (req, res) -> "Hello Spark!");

    // url /test-view
    // simple template "test-view.ftl"
    get(
        "/test-view",
        (req, res) -> {
          Map<String, Object> viewModel = new HashMap<>();
          viewModel.put("message", "Hello Spark!");

          return new ModelAndView(viewModel, "test-view.ftl");
        },
        new FreeMarkerEngine());

    // url /books
    // data bound template
    get(
        "/books",
        (req, res) -> {
          Map<String, Object> viewModel = new HashMap<>();
          viewModel.put("message", "Books");

          List<Book> books = model.getBooks();
          viewModel.put("books", books);
          return new ModelAndView(viewModel, "books.ftl");
        },
        new FreeMarkerEngine());

    // url /books/new
    // initial get of input form for new book in database
    get(
        "/books/new",
        (req, res) -> {
          Map<String, Object> viewModel = new HashMap<>();
          viewModel.put("message", "Add Book");
          return new ModelAndView(viewModel, "new-book.ftl");
        },
        new FreeMarkerEngine());

    // url /books/new
    // subsequent post of new book data back to the
    // server to get saved back to the database
    post(
        "/books/new",
        (req, res) -> {
          // todo: add response book to database, use custom viewModel class
          MultiMap<String> params = new MultiMap<String>();
          UrlEncoded.decodeTo(req.body(), params, "UTF-8");
          NewBookEditModel editModel = new NewBookEditModel();
          BeanUtils.populate(editModel, params);

          long id =
              model.createBook(
                  editModel.getTitle(), editModel.getAuthor(), editModel.getImageUrl());
          res.redirect("/books");
          halt();
          return id; // ?? json & rest??
        });

    get(
        "/books/delete/:id",
        (req, res) -> {
          int id = Integer.parseInt(req.params().get(":id"));
          model.deleteBook(id);

          res.redirect("/books");
          halt();

          return null;
        });

    // url /spi-test
    // json testbed page "spi-test.ftl"
    get(
        "/spi-test",
        (req, res) -> {
          Map<String, Object> viewModel = new HashMap<>();
          viewModel.put("message", "SPI Test Page");

          List<Book> books = model.getBooks();
          viewModel.put("books", books);

          return new ModelAndView(viewModel, "spi-test.ftl");
        },
        new FreeMarkerEngine());

    // Additional JSON Services?
  }
Пример #5
0
  public static void main(String[] args) throws SQLException {

    Connection db =
        DriverManager.getConnection(
            "jdbc:mysql://127.0.0.1:3306/quiz?useSSL=false", "root", "root");
    Entity.setDb(db);

    ClasspathLoader loader = new ClasspathLoader();
    loader.setPrefix("views");
    loader.setSuffix(".html.twig");

    Cache<Object, PebbleTemplate> cache = CacheBuilder.newBuilder().maximumSize(0).build();

    PebbleEngine pebbleEngine =
        new PebbleEngine.Builder()
            .defaultLocale(Locale.GERMAN)
            .loader(loader)
            .templateCache(cache)
            .build();

    PebbleTemplateEngine engine = new PebbleTemplateEngine(pebbleEngine);

    Spark.staticFileLocation("public");

    Spark.get(
        "/stop",
        (request, response) -> {
          Spark.stop();
          return null;
        });

    Spark.get(
        "/",
        (request, response) -> {
          response.redirect("/spiel/start");
          return null;
        });

    Spark.get(
        "/login",
        (request, response) -> {
          return new ModelAndView(null, "login");
        },
        engine);

    Spark.post(
        "/login",
        (request, response) -> {
          Spieler spieler = Spieler.findeNachEmail(request.queryParams("email"));
          Session session = request.session(true);
          if (spieler != null && spieler.istPasswortKorrekt(request.queryParams("passwort"))) {
            session.attribute("spieler", spieler);
            response.redirect("/spiel/start");
          } else {
            session.removeAttribute("spieler");
            response.redirect("/login");
          }
          return null;
        });

    Spark.get(
        "/logout",
        (request, response) -> {
          request.session(true).removeAttribute("spieler");
          response.redirect("/login");
          return null;
        });

    Spark.before(
        "/admin/*",
        (request, response) -> {
          Session session = request.session(true);
          if (session.attribute("spieler") == null) {
            response.redirect("/login");
            Spark.halt(401);
          }
        });

    Spark.before(
        "/spiel/*",
        (request, response) -> {
          Session session = request.session(true);
          if (session.attribute("spieler") == null) {
            response.redirect("/login");
            Spark.halt(401);
          }
        });

    Spark.get(
        "/spiel/start",
        (request, response) -> {
          Spieler spieler = request.session(true).attribute("spieler");
          ArrayList<Zuordnung> zuordnungen = Zuordnung.findeUnbeantworteteNachSpieler(spieler);
          if (zuordnungen.size() > 0) {
            response.redirect("/spiel/runde");
            return null;
          }
          Map<String, Object> werte = new HashMap<>();
          werte.put("fragen", Frage.findeAlle());
          return new ModelAndView(werte, "spiel_start");
        },
        engine);

    Spark.post(
        "/spiel/start",
        (request, response) -> {
          Spieler spieler = request.session(true).attribute("spieler");
          ArrayList<Frage> fragen = Frage.findeAlle();
          Collections.shuffle(fragen);
          int anzahl = Integer.parseInt(request.queryParams("anzahl").trim());
          Runde runde = new Runde(spieler);
          for (int i = 0; i < anzahl; i++) {
            new Zuordnung(fragen.get(i), runde).speichern();
          }
          response.redirect("/spiel/runde");
          return null;
        });

    Spark.get(
        "/spiel/runde",
        (request, response) -> {
          Spieler spieler = request.session(true).attribute("spieler");
          ArrayList<Zuordnung> zuordnungen = Zuordnung.findeUnbeantworteteNachSpieler(spieler);
          if (zuordnungen.isEmpty()) {
            response.redirect("/spiel/zusammenfassung");
            Spark.halt();
            return null;
          } else {
            Map<String, Object> werte = new HashMap<>();
            Zuordnung naechsteZuordung = zuordnungen.get(0);
            naechsteZuordung.setGestellt();
            werte.put("zuordnung", naechsteZuordung);
            return new ModelAndView(werte, "spiel_runde");
          }
        },
        engine);

    Spark.post(
        "/spiel/runde",
        (request, response) -> {
          Zuordnung zuordnung = Zuordnung.findeNachId(request.queryParams("zuordnung_id"));
          Antwort antwort = Antwort.findeNachId(request.queryParams("antwort_id"));
          zuordnung.setBeantwortet();
          zuordnung.setRichtig(antwort.isRichtig());
          zuordnung.speichern();
          response.redirect("/spiel/runde");
          return null;
        });

    Spark.get(
        "/spiel/zusammenfassung",
        (request, response) -> {
          Map<String, Object> werte = new HashMap<>();
          Spieler spieler = request.session(true).attribute("spieler");
          ArrayList<Zuordnung> zuordnungen = Zuordnung.findeNachSpieler(spieler);
          int richtigeAntworten = 0;
          int beantworteteFragen = 0;
          for (Zuordnung zuordnung : zuordnungen) {
            if (zuordnung.getBeantwortet() != null) {
              beantworteteFragen++;
              if (zuordnung.isRichtig()) {
                richtigeAntworten++;
              }
            }
          }
          werte.put("gestellteFragen", zuordnungen.size());
          werte.put("richtigeAntworten", richtigeAntworten);
          werte.put("beantworteteFragen", beantworteteFragen);
          return new ModelAndView(werte, "spiel_zusammenfassung");
        },
        engine);

    Spark.get(
        "/admin/frage",
        (request, response) -> {
          Map<String, Object> werte = new HashMap<>();
          werte.put("fragen", Frage.findeAlle());
          return new ModelAndView(werte, "admin_frage");
        },
        engine);

    Spark.post(
        "/admin/frage/neu",
        (request, response) -> {
          String aufgabe = request.queryParams("aufgabe").trim();
          if (!aufgabe.isEmpty()) {
            new Frage(aufgabe).speichern();
          }
          response.redirect("/admin/frage");
          return null;
        });

    Spark.get(
        "/admin/frage/loeschen/:frage_id",
        (request, response) -> {
          Frage.findeNachId(request.params(":frage_id")).loeschen();
          response.redirect("/admin/frage");
          return null;
        });

    Spark.get(
        "/admin/frage/aendern/:frage_id",
        (request, response) -> {
          Map<String, Object> werte = new HashMap<>();
          werte.put("frage", Frage.findeNachId(request.params(":frage_id")));
          return new ModelAndView(werte, "admin_frage_aendern");
        },
        engine);

    Spark.post(
        "/admin/frage/aendern",
        (request, response) -> {
          Frage zuAenderndeFrage = Frage.findeNachId(request.queryParams("frage_id"));
          zuAenderndeFrage.setAufgabe(request.queryParams("aufgabe").trim());
          zuAenderndeFrage.speichern();
          response.redirect("/admin/frage");
          return null;
        });

    Spark.get(
        "/admin/frage/:frage_id/antwort",
        (request, response) -> {
          Map<String, Object> werte = new HashMap<>();
          Frage frage = Frage.findeNachId(request.params(":frage_id"));
          werte.put("frage", frage);
          werte.put("antworten", frage.getAntworten());
          return new ModelAndView(werte, "admin_frage_antwort");
        },
        engine);

    Spark.post(
        "/admin/antwort/neu",
        (request, response) -> {
          Frage frage = Frage.findeNachId(request.queryParams("frage_id"));
          String loesung = request.queryParams("loesung");
          String richtig = request.queryParams("richtig");
          Antwort antwort;
          if (richtig != null) {
            for (Antwort andereAntwort : Antwort.findeNachFrage(frage)) {
              if (andereAntwort.isRichtig()) {
                andereAntwort.setRichtig(false);
                andereAntwort.speichern();
              }
            }
            antwort = new Antwort(loesung, true, frage);
          } else {
            antwort = new Antwort(loesung, false, frage);
          }
          antwort.speichern();
          response.redirect("/admin/frage/" + frage.getId() + "/antwort");
          return null;
        });

    Spark.post(
        "/admin/frage/:frage_id/antwort/richtig/aendern",
        (Request request, Response response) -> {
          int richtigeAntwortId = Integer.parseInt(request.queryParams("richtig").trim());
          Frage frage = Frage.findeNachId(request.params(":frage_id"));
          for (Antwort antwort : Antwort.findeNachFrage(frage)) {
            if (antwort.isRichtig() && antwort.getId() != richtigeAntwortId) {
              antwort.setRichtig(false);
              antwort.speichern();
            } else if (!antwort.isRichtig() && antwort.getId() == richtigeAntwortId) {
              antwort.setRichtig(true);
              antwort.speichern();
            }
          }
          response.redirect("/admin/frage/" + frage.getId() + "/antwort");
          return null;
        });

    Spark.get(
        "/admin/antwort/loeschen/:antwort_id",
        (request, response) -> {
          Antwort antwort = Antwort.findeNachId(request.params(":antwort_id"));
          antwort.loeschen();
          response.redirect("/admin/frage/" + antwort.getFrage().getId() + "/antwort");
          return null;
        });

    Spark.get(
        "/admin/antwort/aendern/:antwort_id",
        (request, response) -> {
          Map<String, Object> werte = new HashMap<>();
          werte.put("antwort", Antwort.findeNachId(request.params(":antwort_id")));
          return new ModelAndView(werte, "admin_frage_antwort_aendern");
        },
        engine);

    Spark.post(
        "/admin/antwort/aendern",
        (Request request, Response response) -> {
          Antwort antwort = Antwort.findeNachId(request.queryParams("antwort_id"));
          antwort.setLoesung(request.queryParams("loesung"));
          antwort.speichern();
          response.redirect("/admin/frage/" + antwort.getFrage().getId() + "/antwort");
          return null;
        });
  }
Пример #6
0
  public UserController() {

    get(
        "dbeb/users",
        "application/json",
        (request, response) -> {
          String email = request.queryParams("facebookId");

          List<User> objs =
              HibernateUtil.getSession()
                  .createCriteria(User.class)
                  .add(Restrictions.eq("facebookId", email))
                  .list();

          return objs;
        },
        new JsonTransformer());

    get(
        "dbeb/users/:id",
        "application/json",
        (request, response) -> {
          long id = Long.parseLong(request.params(":id"));
          User obj = (User) HibernateUtil.getSession().get(User.class, id);
          if (obj == null) halt(404);
          return obj;
        },
        new JsonTransformer());

    post(
        "dbeb/users",
        "application/json",
        (request, response) -> {
          User obj = JacksonUtil.readValue(request.body(), User.class);
          HibernateUtil.getSession().saveOrUpdate(obj);
          response.status(201);
          return obj;
        },
        new JsonTransformer());

    put(
        "dbeb/users/:id",
        "application/json",
        (request, response) -> {
          long id = Long.parseLong(request.params(":id"));
          User obj = (User) HibernateUtil.getSession().get(User.class, id);
          if (obj == null) halt(404);
          obj = JacksonUtil.readValue(request.body(), User.class);
          obj = (User) HibernateUtil.getSession().merge(obj);
          return obj;
        },
        new JsonTransformer());

    delete(
        "dbeb/users/:id",
        (request, response) -> {
          long id = Long.parseLong(request.params(":id"));
          User obj = (User) HibernateUtil.getSession().get(User.class, id);
          if (obj == null) halt(404);
          HibernateUtil.getSession().delete(obj);
          response.status(204);
          return "";
        });
  }
Пример #7
0
 public static void throwViolations(List<ConstraintViolation> violations) throws HaltException {
   // TODO: Proper error messages
   ConstraintViolation first = violations.get(0);
   halt(400, first.getMessage());
 }
Пример #8
0
  public static Object getRoutes(Request req, Response res) {

    List<Route> routes = new ArrayList<>();
    List<String> feeds = new ArrayList();

    if (req.queryParams("feed") != null) {

      for (String feedId : req.queryParams("feed").split(",")) {
        if (ApiMain.getFeedSource(feedId) != null) {
          feeds.add(feedId);
        }
      }
      if (feeds.size() == 0) {
        halt(404, "Must specify valid feed id.");
      }
      // If feed is only param.
      else if (req.queryParams().size() == 1 && req.params("id") == null) {
        for (String feedId : req.queryParams("feed").split(",")) {
          FeedSource feedSource = ApiMain.getFeedSource(feedId);
          if (feedSource != null) routes.addAll(feedSource.feed.routes.values());
        }
        return routes;
      }
    } else {
      //            res.body("Must specify valid feed id.");
      //            return "Must specify valid feed id.";
      halt(404, "Must specify valid feed id.");
    }

    // get specific route
    if (req.params("id") != null) {
      Route r = ApiMain.getFeedSource(feeds.get(0)).feed.routes.get(req.params("id"));
      if (r != null) // && currentUser(req).hasReadPermission(s.projectId))
      return r;
      else halt(404, "Route " + req.params("id") + " not found");
    }
    // bounding box
    else if (req.queryParams("max_lat") != null
        && req.queryParams("max_lon") != null
        && req.queryParams("min_lat") != null
        && req.queryParams("min_lon") != null) {
      Coordinate maxCoordinate =
          new Coordinate(
              Double.valueOf(req.queryParams("max_lon")),
              Double.valueOf(req.queryParams("max_lat")));
      Coordinate minCoordinate =
          new Coordinate(
              Double.valueOf(req.queryParams("min_lon")),
              Double.valueOf(req.queryParams("min_lat")));
      Envelope searchEnvelope = new Envelope(maxCoordinate, minCoordinate);
      for (String feedId : feeds) {
        // TODO: these are actually patterns being returned, NOT routes
        List<Route> searchResults = ApiMain.getFeedSource(feedId).routeIndex.query(searchEnvelope);
        routes.addAll(searchResults);
      }
      return routes;
    }
    // lat lon + radius
    else if (req.queryParams("lat") != null && req.queryParams("lon") != null) {
      Coordinate latLon =
          new Coordinate(
              Double.valueOf(req.queryParams("lon")), Double.valueOf(req.queryParams("lat")));
      if (req.queryParams("radius") != null) {
        RoutesController.radius = Double.valueOf(req.queryParams("radius"));
      }
      Envelope searchEnvelope = GeomUtil.getBoundingBox(latLon, radius);

      for (String feedId : feeds) {
        List<Route> searchResults = ApiMain.getFeedSource(feedId).routeIndex.query(searchEnvelope);
        routes.addAll(searchResults);
      }
      return routes;
    } else if (req.queryParams("name") != null) {
      System.out.println(req.queryParams("name"));

      for (String feedId : feeds) {
        System.out.println("looping feed: " + feedId);

        // Check if feed is specified in feed sources requested
        // TODO: Check if user has access to feed source? (Put this in the before call.)
        //                if (Arrays.asList(feeds).contains(entry.getKey())) {
        System.out.println("checking feed: " + feedId);

        // search query must be in upper case to match radix tree keys
        Iterable<Route> searchResults =
            ApiMain.getFeedSource(feedId)
                .routeTree
                .getValuesForKeysContaining(req.queryParams("name").toUpperCase());
        for (Route route : searchResults) {
          routes.add(route);
        }
      }

      return routes;
    }
    // query for stop_id (i.e., get all routes that operate along patterns for a given stop)
    else if (req.queryParams("stop") != null) {
      return getRoutesForStop(req, feeds);
    }

    return null;
  }