fix: small refactor in actor plug (#99)

lib/ash_admin/actor_plug/plug.ex

@@ -8,24 +8,15 @@ defmodule AshAdmin.ActorPlug.Plug do
   def actor_assigns(socket, session) do
     otp_app = socket.endpoint.config(:otp_app)
     domains = domains(otp_app)
-
+    session = Phoenix.LiveView.get_connect_params(socket) || session
-    session =
-      Phoenix.LiveView.get_connect_params(socket) || session
-
-    actor_paused =
-      if is_nil(session["actor_paused"]) do
-        true
-      else
-        session_bool(session["actor_paused"])
-      end
 
     [
       actor: actor_from_session(socket.endpoint, session),
       actor_domain: actor_domain_from_session(socket.endpoint, session),
       actor_resources: actor_resources(domains),
-      authorizing: session_bool(session["actor_authorizing"]),
+      actor_paused: session_bool(session["actor_paused"], true),
-      tenant: session["tenant"],
+      authorizing: session_bool(session["actor_authorizing"], false),
-      actor_paused: actor_paused
+      tenant: session["tenant"]
     ]
   end
 
@@ -43,30 +34,16 @@ defmodule AshAdmin.ActorPlug.Plug do
       end
 
     case conn.cookies do
-      %{"actor_resource" => "undefined"} ->
+      session = %{
-        conn
-
-      session ->
-        case session do
-          %{
         "actor_resource" => resource,
         "actor_domain" => domain,
         "actor_action" => action,
         "actor_primary_key" => primary_key
-          } ->
+      }
-            authorizing = session["actor_authorizing"] || false
+      when resource != "undefined" ->
-
-            actor_paused =
-              if is_nil(session["actor_paused"]) do
-                true
-              else
-                session["actor_paused"]
-              end
-
         actor = actor_from_session(conn.private.phoenix_endpoint, session)
-
+        authorizing = session_bool(session["actor_authorizing"], false)
-            authorizing = session_bool(authorizing)
+        actor_paused = session_bool(session["actor_paused"], true)
-            actor_paused = session_bool(actor_paused)
 
         conn
         |> Plug.Conn.put_session(:actor_resource, resource)
@@ -76,7 +53,6 @@ defmodule AshAdmin.ActorPlug.Plug do
         |> Plug.Conn.put_session(:actor_authorizing, authorizing)
         |> Plug.Conn.put_session(:actor_paused, actor_paused)
         |> Plug.Conn.assign(:actor, actor)
-            |> Plug.Conn.assign(:authorizing, authorizing || false)
         |> Plug.Conn.assign(:actor_paused, actor_paused)
         |> Plug.Conn.assign(:authorizing, authorizing)
 
@@ -84,9 +60,8 @@ defmodule AshAdmin.ActorPlug.Plug do
         conn
     end
   end
-  end
 
-  defp session_bool(value) do
+  defp session_bool(value, default) do
     case value do
       "true" ->
         true
@@ -101,20 +76,15 @@ defmodule AshAdmin.ActorPlug.Plug do
         boolean
 
       nil ->
-        false
+        default
     end
   end
 
   defp actor_resources(domains) do
-    domains
+    for domain <- domains,
-    |> Enum.flat_map(fn domain ->
+        resource <- Ash.Domain.Info.resources(domain),
-      domain
+        AshAdmin.Helpers.primary_action(resource, :read) && AshAdmin.Resource.actor?(resource),
-      |> Ash.Domain.Info.resources()
+        do: {domain, resource}
-      |> Enum.filter(fn resource ->
-        AshAdmin.Helpers.primary_action(resource, :read) && AshAdmin.Resource.actor?(resource)
-      end)
-      |> Enum.map(fn resource -> {domain, resource} end)
-    end)
   end
 
   defp domains(otp_app) do
@@ -124,55 +94,45 @@ defmodule AshAdmin.ActorPlug.Plug do
   end
 
   defp actor_domain_from_session(endpoint, %{"actor_domain" => domain}) do
-    otp_app = endpoint.config(:otp_app)
+    endpoint.config(:otp_app)
-    domains = Application.get_env(otp_app, :ash_domains)
+    |> Application.get_env(:ash_domains)
-
+    |> Enum.find(&(AshAdmin.Domain.show?(&1) && AshAdmin.Domain.name(&1) == domain))
-    Enum.find(domains, fn allowed_domain ->
-      AshAdmin.Domain.show?(allowed_domain) && AshAdmin.Domain.name(allowed_domain) == domain
-    end)
   end
 
   defp actor_domain_from_session(_, _), do: nil
 
-  defp actor_from_session(endpoint, %{
+  defp actor_from_session(
+         endpoint,
+         session = %{
            "actor_resource" => resource,
            "actor_domain" => domain,
            "actor_primary_key" => primary_key,
            "actor_action" => action
-       })
+         }
+       )
        when not is_nil(resource) and not is_nil(domain) do
-    otp_app = endpoint.config(:otp_app)
+    domain = actor_domain_from_session(endpoint, session)
-    domains = Application.get_env(otp_app, :ash_domains)
-
-    domain =
-      Enum.find(domains, fn allowed_domain ->
-        AshAdmin.Domain.show?(allowed_domain) && AshAdmin.Domain.name(allowed_domain) == domain
-      end)
 
     resource =
       if domain do
         domain
         |> Ash.Domain.Info.resources()
-        |> Enum.find(fn domain_resource ->
+        |> Enum.find(&(AshAdmin.Resource.name(&1) == resource))
-          AshAdmin.Resource.name(domain_resource) == resource
-        end)
       end
 
-    if domain && resource do
+    case resource && decode_primary_key(resource, primary_key) do
+      {:ok, filter} ->
         action =
           if action do
             Ash.Resource.Info.action(resource, String.to_existing_atom(action), :read)
           end
 
-      case decode_primary_key(resource, primary_key) do
-        :error ->
-          nil
-
-        {:ok, filter} ->
         resource
         |> Ash.Query.filter(^filter)
         |> Ash.read_one!(action: action, authorize?: false, domain: domain)
-      end
+
+      _ ->
+        nil
     end
   end