feat(OTP): Updated the API to use the graphql endpoint of OTP (#1791)

* feat(deps): Added absinthe_client and updated mint dependency

* feat(OTP): Updated the API to use the graphql endpoint of OTP

* Fixed tests

* More cleanup

* Increased walk reluctance and fixed unit tests

* feat(OpenTripPlanner): add stop ID to response (#1792)

* Fixed unite tests

* Fixed error messages, and error tests

---------

Co-authored-by: Cristen Jones <[email protected]>

apps/site/lib/site_web/views/trip_plan_view.ex

@@ -624,7 +624,7 @@ defmodule SiteWeb.TripPlanView do
         acc
       else
         name =
-          if leg.name && leg.name =~ "Shuttle",
+          if leg.long_name && leg.long_name =~ "Shuttle",
             do: Format.name(:shuttle),
             else: Format.name(highest_fare.name)
 

apps/site/test/site/trip_plan/query_test.exs

@@ -226,7 +226,6 @@ defmodule Site.TripPlan.QueryTest do
       assert %Query{} = from_query(params, @connection_opts, @date_opts)
 
       inaccessible_opts = [
-        max_walk_distance: 805,
         wheelchair_accessible?: false,
         depart_at: @date_time
       ]

apps/trip_plan/lib/trip_plan.ex

@@ -4,12 +4,6 @@ defmodule TripPlan do
   """
   alias Util.Position
 
-  # Default options for the plans
-  @default_opts [
-    # ~0.5 miles
-    max_walk_distance: 805
-  ]
-
   @doc """
   Tries to describe how to get between two places.
   """
@@ -25,7 +19,7 @@ defmodule TripPlan do
       from,
       to,
       connection_opts,
-      Keyword.merge(@default_opts, opts),
+      opts,
       parent
     ])
   end

apps/trip_plan/lib/trip_plan/api.ex

@@ -14,7 +14,6 @@ defmodule TripPlan.Api do
           | {:depart_at, DateTime.t()}
           | {:wheelchair_accessible?, boolean}
           | {:optimize_for, :less_walking | :fewest_transfers}
-          | {:max_walk_distance, float}
   @type plan_opts :: [plan_opt]
 
   @type connection_opts :: [user_id: integer, force_otp1: boolean, force_otp2: boolean]

apps/trip_plan/lib/trip_plan/api/open_trip_planner.ex

@@ -3,32 +3,32 @@ defmodule TripPlan.Api.OpenTripPlanner do
   @behaviour TripPlan.Api
   require Logger
   import __MODULE__.Builder, only: [build_params: 3]
-  import __MODULE__.Parser, only: [parse_json: 1]
-  alias TripPlan.NamedPosition
-  alias Util.Position
+  import __MODULE__.Parser, only: [parse_ql: 2]
 
   def plan(from, to, connection_opts, opts, _parent) do
     plan(from, to, connection_opts, opts)
   end
 
   @impl true
   def plan(from, to, connection_opts, opts) do
+    accessible? = Keyword.get(opts, :wheelchair_accessible?, false)
+
     with {:ok, params} <- build_params(from, to, opts) do
-      params =
-        Map.merge(
-          params,
-          %{
-            "fromPlace" => location(from),
-            "toPlace" => location(to),
-            "showIntermediateStops" => "true",
-            "format" => "json",
-            "locale" => "en"
-          }
+      param_string = Enum.map_join(params, "\n", fn {key, val} -> ~s{#{key}: #{val}} end)
+
+      graph_ql_query = """
+      {
+        plan(
+          #{param_string}
         )
+        #{itinerary_shape()}
+      }
+      """
 
-      root_url = params["root_url"] || pick_url(connection_opts)
-      full_url = "#{root_url}/otp/routers/default/plan"
-      send_request(full_url, params, &parse_json/1)
+      root_url = Keyword.get(opts, :root_url, nil) || pick_url(connection_opts)
+      graphql_url = "#{root_url}/otp/routers/default/index/"
+
+      send_request(graphql_url, graph_ql_query, accessible?, &parse_ql/2)
     end
   end
 
@@ -86,30 +86,34 @@ defmodule TripPlan.Api.OpenTripPlanner do
     Util.config(:trip_plan, OpenTripPlanner, key)
   end
 
-  defp send_request(url, params, parser) do
-    with {:ok, response} <- log_response(url, params),
-         %{status_code: 200, body: body} <- response do
-      parser.(body)
+  defp send_request(url, query, accessible?, parser) do
+    with {:ok, response} <- log_response(url, query),
+         %{status: 200, body: body} <- response do
+      parser.(body, accessible?)
     else
-      %{status_code: _} = response ->
+      %{status: _} = response ->
         {:error, response}
 
       error ->
         error
     end
   end
 
-  defp log_response(url, params) do
+  defp log_response(url, query) do
+    graphql_req =
+      Req.new(base_url: url, headers: build_headers(config(:wiremock_proxy)))
+      |> AbsintheClient.attach()
+
     {duration, response} =
       :timer.tc(
-        HTTPoison,
-        :get,
-        [url, build_headers(config(:wiremock_proxy)), [params: params, recv_timeout: 10_000]]
+        Req,
+        :post,
+        [graphql_req, [graphql: query]]
       )
 
     _ =
       Logger.info(fn ->
-        "#{__MODULE__}.plan_response url=#{url} is_otp2=#{String.contains?(url, config(:otp2_url))} params=#{inspect(params)} #{status_text(response)} duration=#{duration / :timer.seconds(1)}"
+        "#{__MODULE__}.plan_response url=#{url} is_otp2=#{String.contains?(url, config(:otp2_url))} query=#{inspect(query)} #{status_text(response)} duration=#{duration / :timer.seconds(1)}"
       end)
 
     response
@@ -122,19 +126,113 @@ defmodule TripPlan.Api.OpenTripPlanner do
 
   defp build_headers(_), do: []
 
-  defp status_text({:ok, %{status_code: code, body: body}}) do
-    "status=#{code} content_length=#{byte_size(body)}"
+  defp status_text({:ok, %{status: code, body: body}}) do
+    string_body = Poison.encode!(body)
+    "status=#{code} content_length=#{byte_size(string_body)}"
   end
 
   defp status_text({:error, error}) do
     "status=error error=#{inspect(error)}"
   end
 
-  defp location(%NamedPosition{} = np) do
-    "#{np.name}::#{Position.latitude(np)},#{Position.longitude(np)}"
-  end
-
-  defp location(position) do
-    "#{Position.latitude(position)},#{Position.longitude(position)}"
+  defp itinerary_shape() do
+    """
+    {
+      routingErrors {
+        code
+        description
+      }
+      itineraries {
+        startTime
+        endTime
+        duration
+        legs {
+          mode
+          startTime
+          endTime
+          distance
+          duration
+          intermediateStops {
+            id
+            gtfsId
+            name
+            desc
+            lat
+            lon
+            code
+            locationType
+          }
+          transitLeg
+          headsign
+          realTime
+          realtimeState
+          agency {
+            id
+            gtfsId
+            name
+          }
+          alerts {
+            id
+            alertHeaderText
+            alertDescriptionText
+          }
+          fareProducts {
+            id
+            product {
+              id
+              name
+              riderCategory {
+                id
+                name
+
+              }
+            }
+          }
+          from {
+            name
+            lat
+            lon
+            departureTime
+            arrivalTime
+            stop {
+              gtfsId
+            }
+          }
+          to {
+            name
+            lat
+            lon
+            departureTime
+            arrivalTime
+            stop {
+              gtfsId
+            }
+          }
+          route {
+            gtfsId
+            longName
+            shortName
+            desc
+            color
+            textColor
+          }
+          trip {
+            gtfsId
+          }
+          steps {
+            distance
+            streetName
+            lat
+            lon
+            relativeDirection
+            stayOn
+          }
+          legGeometry {
+            points
+          }
+        }
+      }
+    }
+    """
   end
 end

apps/trip_plan/lib/trip_plan/api/open_trip_planner/builder.ex

@@ -1,24 +1,31 @@
 defmodule TripPlan.Api.OpenTripPlanner.Builder do
   alias TripPlan.Api.OpenTripPlanner, as: OTP
-  alias Util.{Polygon, Position}
-  @ten_miles 16_093
+  alias TripPlan.NamedPosition
+  alias Util.Position
 
   @doc "Convert general planning options into query params for OTP"
   @spec build_params(Position.t(), Position.t(), TripPlan.Api.plan_opts()) ::
           {:ok, %{String.t() => String.t()}} | {:error, any}
   def build_params(from, to, opts) do
-    opts = configure_walk_distance(from, to, opts)
-    do_build_params(opts, %{"mode" => "TRANSIT,WALK", "walkReluctance" => 5})
+    from_string = location(from)
+    to_string = location(to)
+    default_mode_string = "[{mode: WALK}, {mode: TRANSIT}]"
+
+    do_build_params(opts, %{
+      "fromPlace" => from_string,
+      "toPlace" => to_string,
+      "transportModes" => default_mode_string,
+      "walkReluctance" => 15,
+      "locale" => "\"en\""
+    })
   end
 
-  defp configure_walk_distance(from, to, opts) do
-    polygon = Application.get_env(:trip_plan, ReducedWalkingArea, [])
+  defp location(%NamedPosition{} = np) do
+    "\"#{np.name}::#{Position.latitude(np)},#{Position.longitude(np)}\""
+  end
 
-    if Polygon.inside?(polygon, from) and Polygon.inside?(polygon, to) do
-      opts
-    else
-      put_in(opts[:max_walk_distance], @ten_miles)
-    end
+  defp location(position) do
+    "\"#{Position.latitude(position)},#{Position.longitude(position)}\""
   end
 
   defp do_build_params([], acc) do
@@ -36,38 +43,13 @@ defmodule TripPlan.Api.OpenTripPlanner.Builder do
     do_build_params(rest, acc)
   end
 
-  defp do_build_params([{:max_walk_distance, meters} | rest], acc) when is_number(meters) do
-    acc = put_in(acc["maxWalkDistance"], "#{meters}")
-    do_build_params(rest, acc)
-  end
-
   defp do_build_params([{:depart_at, %DateTime{} = datetime} | rest], acc) do
-    local = Timex.to_datetime(datetime, OTP.config(:timezone))
-    date = Timex.format!(local, "{ISOdate}")
-    time = Timex.format!(local, "{h12}:{0m}{am}")
-
-    acc =
-      Map.merge(acc, %{
-        "date" => date,
-        "time" => time,
-        "arriveBy" => "false"
-      })
-
+    acc = do_date_time("false", datetime, acc)
     do_build_params(rest, acc)
   end
 
   defp do_build_params([{:arrive_by, %DateTime{} = datetime} | rest], acc) do
-    local = Timex.to_datetime(datetime, OTP.config(:timezone))
-    date = Timex.format!(local, "{ISOdate}")
-    time = Timex.format!(local, "{h12}:{0m}{am}")
-
-    acc =
-      Map.merge(acc, %{
-        "date" => date,
-        "time" => time,
-        "arriveBy" => "true"
-      })
-
+    acc = do_date_time("true", datetime, acc)
     do_build_params(rest, acc)
   end
 
@@ -76,24 +58,37 @@ defmodule TripPlan.Api.OpenTripPlanner.Builder do
   end
 
   defp do_build_params([{:mode, [_ | _] = modes} | rest], acc) do
-    all_modes = Enum.join(modes, ",") <> ",WALK"
-    do_build_params(rest, Map.put(acc, "mode", all_modes))
+    all_modes = Enum.map(modes, fn m -> "{mode: #{m}}" end)
+    joined_modes = "[#{Enum.join(all_modes, ", ")}, {mode: WALK}]"
+    do_build_params(rest, Map.put(acc, "transportModes", joined_modes))
   end
 
   defp do_build_params([{:optimize_for, :less_walking} | rest], acc) do
-    do_build_params(rest, Map.put(acc, "walkReluctance", 17))
+    do_build_params(rest, Map.put(acc, "walkReluctance", 27))
   end
 
   defp do_build_params([{:optimize_for, :fewest_transfers} | rest], acc) do
     do_build_params(rest, Map.put(acc, "transferPenalty", 100))
   end
 
-  defp do_build_params([{:root_url, url} | rest], acc) do
-    acc = Map.put(acc, "root_url", url)
+  # param is used for testing, ignore
+  defp do_build_params([{:root_url, _} | rest], acc) do
     do_build_params(rest, acc)
   end
 
   defp do_build_params([option | _], _) do
     {:error, {:bad_param, option}}
   end
+
+  defp do_date_time(arriveBy, %DateTime{} = datetime, acc) do
+    local = Timex.to_datetime(datetime, OTP.config(:timezone))
+    date = Timex.format!(local, "\"{ISOdate}\"")
+    time = Timex.format!(local, "\"{h12}:{0m}{am}\"")
+
+    Map.merge(acc, %{
+      "date" => date,
+      "time" => time,
+      "arriveBy" => arriveBy
+    })
+  end
 end