Add cron sorting using standard component

Author: sorentwo

lib/oban/web/pages/crons_page.ex

@@ -3,7 +3,9 @@ defmodule Oban.Web.CronsPage do
 
   use Oban.Web, :live_component
 
-  alias Oban.Web.{Cron, CronQuery, Page}
+  alias Oban.Web.{Cron, CronQuery, Page, SortComponent}
+
+  @known_params ~w(sort_by sort_dir)
 
   @impl Phoenix.LiveComponent
   def render(assigns) do
@@ -19,6 +21,15 @@ defmodule Oban.Web.CronsPage do
 
             <h2 class="text-lg dark:text-gray-200 leading-4 font-bold">Crons</h2>
           </div>
+
+          <div class="pl-3 ml-auto">
+            <SortComponent.select
+              id="crons-sort"
+              by={~w(worker schedule last_run next_run)}
+              page={:crons}
+              params={@params}
+            />
+          </div>
         </div>
 
         <div id="crons-table" class="min-w-full">
@@ -107,7 +118,7 @@ defmodule Oban.Web.CronsPage do
 
           <div class="w-20 pr-3 flex justify-end items-center space-x-1">
             <span
-              id={"cron-state-icon-#{@cron.worker}"}
+              id={"cron-state-icon-#{Cron.name(@cron)}"}
               class="py-1.5 px-2 text-xs"
               phx-hook="Tippy"
               data-title={state_title(@cron)}
@@ -158,17 +169,32 @@ defmodule Oban.Web.CronsPage do
 
   @impl Page
   def handle_mount(socket) do
-    assign_new(socket, :crontab, fn -> crontab(socket.assigns.conf) end)
+    default = fn -> %{sort_by: "worker", sort_dir: "asc"} end
+
+    socket
+    |> assign_new(:default_params, default)
+    |> assign_new(:params, default)
+    |> assign_new(:crontab, fn -> crontab(socket.assigns.conf) end)
   end
 
   @impl Page
   def handle_refresh(socket) do
-    assign(socket, crontab: crontab(socket.assigns.conf))
+    crons = CronQuery.all_crons(socket.assigns.params, socket.assigns.conf)
+    assign(socket, crontab: crons)
   end
 
   @impl Page
-  def handle_params(_params, _uri, socket) do
-    socket = assign(socket, page_title: page_title("Crons"))
+  def handle_params(params, _uri, socket) do
+    params =
+      params
+      |> Map.take(@known_params)
+      |> decode_params()
+
+    socket =
+      socket
+      |> assign(page_title: page_title("Crons"))
+      |> assign(params: Map.merge(socket.assigns.default_params, params))
+      |> handle_refresh()
 
     {:noreply, socket}
   end

lib/oban/web/queries/cron_query.ex

@@ -7,24 +7,35 @@ defmodule Oban.Web.CronQuery do
   alias Oban.{Job, Met, Repo}
   alias Oban.Web.Cron
 
-  def all_crons(_params, conf) do
+  def all_crons(params, conf) do
+    {sort_by, sort_dir} = parse_sort(params)
+
     # TODO: Cache these values and avoid running the query too frequently
     crontab = Met.crontab(conf.name)
-    workers = Enum.map(crontab, &elem(&1, 1))
-    history = crontab_history(workers, conf)
-
-    for {expr, worker, opts} <- crontab do
-      fields = [
-        expression: expr,
-        worker: worker,
-        opts: opts,
-        next_at: next_at(expr),
-        last_at: last_at(history, worker),
-        last_state: get_in(history, [worker, :state])
-      ]
-
-      struct!(Cron, fields)
-    end
+
+    history =
+      crontab
+      |> Enum.map(&elem(&1, 1))
+      |> crontab_history(conf)
+
+    crontab
+    |> Enum.map(&new(&1, history))
+    |> Enum.sort_by(&order(&1, sort_by), sort_dir)
+  end
+
+  # Construction
+
+  defp new({expr, worker, opts}, history) do
+    fields = [
+      expression: expr,
+      worker: worker,
+      opts: opts,
+      next_at: next_at(expr),
+      last_at: last_at(history, worker),
+      last_state: get_in(history, [worker, :state])
+    ]
+
+    struct!(Cron, fields)
   end
 
   # TODO: Correctly handle jobs with different args
@@ -76,4 +87,26 @@ defmodule Oban.Web.CronQuery do
     |> Expression.parse!()
     |> Expression.next_at()
   end
+
+  # Sorting
+
+  defp parse_sort(%{sort_by: "last_run", sort_dir: dir}) do
+    {:last_run, {String.to_existing_atom(dir), DateTime}}
+  end
+
+  defp parse_sort(%{sort_by: "next_run", sort_dir: dir}) do
+    {:next_run, {String.to_existing_atom(dir), DateTime}}
+  end
+
+  defp parse_sort(%{sort_by: sby, sort_dir: dir}) do
+    {String.to_existing_atom(sby), String.to_existing_atom(dir)}
+  end
+
+  defp parse_sort(_params), do: {:worker, :asc}
+
+  defp order(%{last_at: nil}, :last_run), do: ~U[2000-01-01 00:00:00Z]
+  defp order(%{last_at: last_at}, :last_run), do: last_at
+  defp order(%{next_at: next_at}, :next_run), do: next_at
+  defp order(%{expression: expression}, :schedule), do: expression
+  defp order(%{worker: worker}, :worker), do: worker
 end

lib/oban/web/queries/queue_query.ex

@@ -93,7 +93,7 @@ defmodule Oban.Web.QueueQuery do
   # Querying
 
   def all_queues(params, %{name: name}) do
-    {sort_by, sort_dir} = atomize_sort(params)
+    {sort_by, sort_dir} = parse_sort(params)
 
     conditions = Map.take(params, filterable())
 
@@ -116,11 +116,11 @@ defmodule Oban.Web.QueueQuery do
     struct!(Queue, %{name: name, checks: checks, counts: counts})
   end
 
-  defp atomize_sort(%{sort_by: sby, sort_dir: dir}) do
+  defp parse_sort(%{sort_by: sby, sort_dir: dir}) do
     {String.to_existing_atom(sby), String.to_existing_atom(dir)}
   end
 
-  defp atomize_sort(_params), do: {:name, :asc}
+  defp parse_sort(_params), do: {:name, :asc}
 
   # Filtering
 

test/oban/web/pages/crons/index_test.exs

@@ -44,6 +44,28 @@ defmodule Oban.Web.Pages.Crons.IndexTest do
     assert table =~ ~r/cron-Oban-Workers-CronB/
   end
 
+  test "sorting crons by different properties", %{live: live} do
+    refresh(live)
+
+    assert has_element?(live, "#crons-sort")
+
+    for mode <- ~w(worker last_run next_run schedule) do
+      change_sort(live, mode)
+
+      assert_patch(live, crons_path(sort_by: mode, sort_dir: "asc"))
+    end
+  end
+
+  defp change_sort(live, mode) do
+    live
+    |> element("a#sort-#{mode}")
+    |> render_click()
+  end
+
+  defp crons_path(params) do
+    "/oban/crons?#{URI.encode_query(params)}"
+  end
+
   defp refresh(live) do
     send(live.pid, :refresh)
   end