tweak: make use of status field in detour list queries

lib/skate/detours/db/detour.ex

@@ -170,6 +170,7 @@ defmodule Skate.Detours.Db.Detour do
         :author_id,
         :activated_at,
         :updated_at,
+        :status,
 
         # Virtual Fields
         :route_id,

lib/skate/detours/detours.ex

@@ -40,59 +40,35 @@ defmodule Skate.Detours.Detours do
       [%Detour{}, ...]
   """
   def active_detours_by_route(route_id) do
-    list_detours()
+    Skate.Detours.Db.Detour.Queries.select_detour_list_info()
+    |> where([detour: d], d.status == :active)
+    |> Repo.all()
     |> Enum.filter(fn detour ->
-      categorize_detour(detour) == :active and detour.route_id == route_id
+      detour.route_id == route_id
     end)
-    |> Enum.map(fn detour -> db_detour_to_detour(detour) end)
+    |> Enum.map(&db_detour_to_detour/1)
   end
 
-  @doc """
-  Returns the detours grouped by active, draft, and past.
-
-  ## Examples
+  def detours_for_user(user_id, status) do
+    Skate.Detours.Db.Detour.Queries.select_detour_list_info()
+    |> apply_user_and_status_filter(user_id, status)
+    |> Repo.all()
+    |> Enum.map(&db_detour_to_detour/1)
+    |> Enum.reject(&is_nil/1)
+  end
 
-      iex> grouped_detours(my_user_id)
-      %{
-        active: [%DetailedDetour{}, ...],
-        draft: nil,
-        past: [%DetailedDetour{}, ...]
-      }
-  """
-  @spec grouped_detours(integer()) :: %{
-          active: list(DetailedDetour.t()) | nil,
-          draft: list(DetailedDetour.t()) | nil,
-          past: list(DetailedDetour.t()) | nil
-        }
-  def grouped_detours(user_id) do
-    detours =
-      list_detours()
-      |> Enum.map(&db_detour_to_detour/1)
-      |> Enum.filter(& &1)
-      |> Enum.group_by(fn
-        %ActivatedDetourDetails{details: %{status: status}} -> status
-        %{status: status} -> status
-      end)
-
-    %{
-      active: Map.get(detours, :active, []),
-      draft:
-        detours
-        |> Map.get(:draft, [])
-        |> Enum.filter(fn detour -> detour.author_id == user_id end),
-      past: Map.get(detours, :past, [])
-    }
+  defp apply_user_and_status_filter(query, user_id, :draft) do
+    where(query, [detour: d], d.status == :draft and d.author_id == ^user_id)
   end
 
-  @spec db_detour_to_detour(Detour.t()) :: DetailedDetour.t() | nil
-  @spec db_detour_to_detour(status :: Detour.status(), Detour.t()) :: DetailedDetour.t() | nil
-  def db_detour_to_detour(%{} = db_detour) do
-    db_detour_to_detour(categorize_detour(db_detour), db_detour)
+  defp apply_user_and_status_filter(query, _user_id, status) do
+    where(query, [detour: d], d.status == ^status)
   end
 
+  @spec db_detour_to_detour(Detour.t()) :: DetailedDetour.t() | ActivatedDetourDetails.t() | nil
   def db_detour_to_detour(
-        :active,
         %{
+          status: :active,
           activated_at: activated_at,
           estimated_duration: estimated_duration
         } = db_detour
@@ -107,21 +83,10 @@ defmodule Skate.Detours.Detours do
       }
   end
 
-  def db_detour_to_detour(
-        status,
-        %{} = db_detour
-      ) do
+  def db_detour_to_detour(%{status: status} = db_detour) do
     DetailedDetour.from(status, db_detour)
   end
 
-  def db_detour_to_detour(state, invalid_detour) do
-    Sentry.capture_message("Detour error: the detour has an outdated schema",
-      extra: %{error: invalid_detour, state: state}
-    )
-
-    nil
-  end
-
   @doc """
   Takes a `Skate.Detours.Db.Detour` struct and a `Skate.Settings.Db.User` id
   and returns a `t:Detour.status/0` based on the state of the detour.

lib/skate_web/channels/detours_channel.ex

@@ -11,7 +11,7 @@ defmodule SkateWeb.DetoursChannel do
   def join_authenticated("detours:active", _message, socket) do
     SkateWeb.Endpoint.subscribe("detours:active")
     %{id: user_id} = Guardian.Phoenix.Socket.current_resource(socket)
-    detours = Detours.grouped_detours(user_id)[:active]
+    detours = Detours.detours_for_user(user_id, :active)
     {:ok, %{data: detours}, socket}
   end
 
@@ -27,7 +27,7 @@ defmodule SkateWeb.DetoursChannel do
   def join_authenticated("detours:past", _message, socket) do
     SkateWeb.Endpoint.subscribe("detours:past")
     %{id: user_id} = Guardian.Phoenix.Socket.current_resource(socket)
-    detours = Detours.grouped_detours(user_id)[:past]
+    detours = Detours.detours_for_user(user_id, :past)
     {:ok, %{data: detours}, socket}
   end
 
@@ -36,7 +36,7 @@ defmodule SkateWeb.DetoursChannel do
   def join_authenticated("detours:draft:" <> author_uuid, _message, socket) do
     SkateWeb.Endpoint.subscribe("detours:draft:" <> author_uuid)
     %{id: user_id} = Guardian.Phoenix.Socket.current_resource(socket)
-    detours = Detours.grouped_detours(user_id)[:draft]
+    detours = Detours.detours_for_user(user_id, :draft)
     {:ok, %{data: detours}, socket}
   end
 

lib/skate_web/controllers/detours_controller.ex

@@ -32,7 +32,13 @@ defmodule SkateWeb.DetoursController do
   def detours(conn, _params) do
     %{id: user_id} = AuthManager.Plug.current_resource(conn)
 
-    detours = Detours.grouped_detours(user_id)
+    detours =
+      [:active, :draft, :past]
+      |> Enum.map(fn status ->
+        Task.async(fn -> {status, Detours.detours_for_user(user_id, status)} end)
+      end)
+      |> Task.await_many()
+      |> Map.new()
 
     json(conn, %{data: detours})
   end