wip: show the transfers

Author: thecristen

apps/api_web/lib/api_web/controllers/transfer_controller.ex

@@ -0,0 +1,49 @@
+defmodule ApiWeb.TransferController do
+  use ApiWeb.Web, :api_controller
+
+  @filters ~w(trip type)s
+  @pagination_opts [:offset, :limit]
+
+  def state_module, do: State.Transfer
+  def index_data(conn, params) do
+
+    with {:ok, filtered} <- Params.filter_params(params, @filters, conn) do
+      filtered
+      |> format_filters()
+      |> State.Transfer.filter_by()
+      |> State.all(Params.filter_opts(params, @pagination_opts, conn))
+    else
+      {:error, _, _} = error -> error
+    end
+  end
+
+  defp format_filters(filters) do
+    filters
+    |> Enum.flat_map(&do_format_filter/1)
+    |> Enum.into(%{})
+  end
+
+  defp do_format_filter({"trip", trip_string}) do
+    case Params.split_on_comma(trip_string) do
+      [] ->
+        []
+
+      trip_ids ->
+        %{from_trip_ids: trip_ids}
+    end
+  end
+
+  defp do_format_filter({"type", type_string}) do
+    case Params.split_on_comma(type_string) do
+      [] ->
+        []
+
+      types ->
+        %{types: types}
+    end
+  end
+
+  defp do_format_filter(_), do: []
+
+  def show_data(_conn, _params), do: []
+end

apps/api_web/lib/api_web/router.ex

@@ -97,6 +97,7 @@ defmodule ApiWeb.Router do
     resources("/trips", TripController, only: [:index, :show])
     resources("/alerts", AlertController, only: [:index, :show])
     resources("/facilities", FacilityController, only: [:index, :show])
+    get("/transfers", TransferController, :index)
     resources("/live_facilities", LiveFacilityController, only: [:index, :show])
     resources("/live-facilities", LiveFacilityController, only: [:index, :show])
     resources("/services", ServiceController, only: [:index, :show])

apps/api_web/lib/api_web/swagger_helpers.ex

@@ -217,6 +217,13 @@ defmodule ApiWeb.SwaggerHelpers do
     Path.parameter(path_object, "filter[#{name}]", :query, :string, desc, format: :time)
   end
 
+  def filter_param(path_object, :trip_id, opts) do
+    desc = opts[:desc] || ""
+
+    clean_opts = Keyword.take(opts, [:type, :required, :name, :in, :desc, :description])
+    filter_param(path_object, :id, Keyword.merge(clean_opts, desc: desc, name: :trip))
+  end
+
   def filter_param(path_object, :stop_id, opts) do
     desc = opts[:desc] || ""
 

apps/api_web/lib/api_web/views/transfer_view.ex

@@ -0,0 +1,17 @@
+defmodule ApiWeb.TransferView do
+  use ApiWeb.Web, :api_view
+
+  attributes([
+    :from_stop_id,
+    :to_stop_id,
+    :min_transfer_time,
+    :min_walk_time,
+    :min_wheelchair_time,
+    :suggested_buffer_time,
+    :wheelchair_transfer,
+    :from_trip_id,
+    :to_trip_id,
+    :transfer_type
+  ])
+
+end

apps/state/lib/state/transfer.ex

@@ -8,4 +8,71 @@ defmodule State.Transfer do
     fetched_filename: "transfers.txt",
     parser: Parse.Transfers,
     recordable: Model.Transfer
+
+  @type filter_opts :: %{
+    optional(:trips) => [Model.Trip.id()],
+    optional(:types) => [String.t()]
+  }
+
+  @type transfer_search :: (-> [Model.Transfer.t()])
+
+  @doc """
+  Applies a filtered search on Transfers based on a map of filter values.
+
+  The allowed filterable keys are:
+    :trips
+    :types
+  """
+  @spec filter_by(filter_opts) :: [Model.Transfer.t()]
+  def filter_by(filters) when is_map(filters) do
+    filters
+    |> build_filtered_searches()
+    |> do_searches()
+  end
+
+  # Generate the functions needed to search concurrently
+  @spec build_filtered_searches(filter_opts, [transfer_search]) :: [transfer_search]
+  defp build_filtered_searches(filters, searches \\ [])
+
+  defp build_filtered_searches(%{types: types} = filters, searches) do
+    types = Enum.map(types, &String.to_integer/1)
+    search_operation = fn -> by_transfer_types(types) end
+
+    filters
+    |> Map.drop([:types])
+    |> build_filtered_searches([search_operation | searches])
+  end
+
+  defp build_filtered_searches(%{trips: trip_ids} = filters, searches) do
+    search_operation = fn -> by_from_trip_ids(trip_ids) end
+
+    filters
+    |> Map.drop([:trips])
+    |> build_filtered_searches([search_operation | searches])
+  end
+
+  defp build_filtered_searches(_, searches), do: searches
+
+  @spec do_searches([transfer_search]) :: [Transfer.t()]
+  defp do_searches([]), do: all()
+
+  defp do_searches(search_operations) do
+    search_results =
+      Stream.map(search_operations, fn search_operation ->
+        case search_operation.() do
+          results when is_list(results) ->
+            results
+
+          _ ->
+            []
+        end
+      end)
+
+    Enum.to_list(
+      Enum.reduce(search_results, :no_results, fn
+        results, :no_results -> MapSet.new(results)
+        results, acc -> results |> MapSet.new() |> MapSet.intersection(acc)
+      end)
+    )
+  end
 end