Merge pull request #166 from Qizot/allow-action-map

Added support for actions map

Author: aesmail

lib/kaffy/resource_form.ex

@@ -336,7 +336,9 @@ defmodule Kaffy.ResourceForm do
         {nil, ""}
 
       messages ->
-        error_msg = Kaffy.ResourceAdmin.humanize_term(field) <> " " <> Enum.join(messages, ", ") <> "!"
+        error_msg =
+          Kaffy.ResourceAdmin.humanize_term(field) <> " " <> Enum.join(messages, ", ") <> "!"
+
         {error_msg, "is-invalid"}
     end
   end
@@ -349,7 +351,9 @@ defmodule Kaffy.ResourceForm do
     end)
   end
 
-  defp build_changeset_value(value) when is_tuple(value), do: value |> Tuple.to_list() |> Enum.join(", ")
+  defp build_changeset_value(value) when is_tuple(value),
+    do: value |> Tuple.to_list() |> Enum.join(", ")
+
   defp build_changeset_value(value), do: to_string(value)
 
   def kaffy_input(conn, changeset, form, field, options) do

lib/kaffy/resource_query.ex

@@ -102,7 +102,7 @@ defmodule Kaffy.ResourceQuery do
 
     query =
       cond do
-        (is_nil(search_fields) || Enum.empty?(search_fields)) || search == "" ->
+        is_nil(search_fields) || Enum.empty?(search_fields) || search == "" ->
           query
 
         true ->
@@ -118,7 +118,9 @@ defmodule Kaffy.ResourceQuery do
               query = from(s in q, join: a in assoc(s, ^association))
 
               Enum.reduce(fields, query, fn f, current_query ->
-                from([..., r] in current_query, or_where: ilike(type(field(r, ^f), :string), ^term))
+                from([..., r] in current_query,
+                  or_where: ilike(type(field(r, ^f), :string), ^term)
+                )
               end)
 
             f, q ->

lib/kaffy_web/controllers/resource_controller.ex

@@ -321,8 +321,7 @@ defmodule KaffyWeb.ResourceController do
     my_resource = Kaffy.Utils.get_resource(conn, context, resource)
     entry = Kaffy.ResourceQuery.fetch_resource(conn, my_resource, id)
     actions = Kaffy.ResourceAdmin.resource_actions(my_resource, conn)
-    action_key = String.to_existing_atom(action_key)
-    [action_record] = Keyword.get_values(actions, action_key)
+    action_record = get_action_record(actions, action_key)
 
     case action_record.action.(conn, entry) do
       {:ok, entry} ->
@@ -344,11 +343,10 @@ defmodule KaffyWeb.ResourceController do
         %{"context" => context, "resource" => resource, "action_key" => action_key} = params
       ) do
     my_resource = Kaffy.Utils.get_resource(conn, context, resource)
-    action_key = String.to_existing_atom(action_key)
     ids = Map.get(params, "ids", "") |> String.split(",")
     entries = Kaffy.ResourceQuery.fetch_list(my_resource, ids)
     actions = Kaffy.ResourceAdmin.list_actions(my_resource, conn)
-    [action_record] = Keyword.get_values(actions, action_key)
+    action_record = get_action_record(actions, action_key)
     kaffy_inputs = Map.get(params, "kaffy-input", %{})
 
     result =
@@ -394,4 +392,16 @@ defmodule KaffyWeb.ResourceController do
         )
     )
   end
+
+  # we received actions as map so we actually use strings as keys
+  defp get_action_record(actions, action_key) when is_map(actions) and is_binary(action_key) do
+    Map.fetch!(actions, action_key)
+  end
+
+  # we received actions as Keyword list so action_key needs to be an atom
+  defp get_action_record(actions, action_key) when is_list(actions) and is_binary(action_key) do
+    action_key = String.to_existing_atom(action_key)
+    [action_record] = Keyword.get_values(actions, action_key)
+    action_record
+  end
 end

mix.exs

@@ -32,6 +32,7 @@ defmodule Kaffy.MixProject do
     [
       {:phoenix, "~> 1.4"},
       {:phoenix_html, "~> 2.11"},
+      {:mock, "~> 0.3.0", only: :test},
       {:ecto, "~> 3.0"},
       {:ex_doc, ">= 0.0.0", only: :dev, runtime: false}
     ]

mix.lock

@@ -8,7 +8,9 @@
   "jumper": {:hex, :jumper, "1.0.1", "3c00542ef1a83532b72269fab9f0f0c82bf23a35e27d278bfd9ed0865cecabff", [:mix], [], "hexpm", "318c59078ac220e966d27af3646026db9b5a5e6703cb2aa3e26bcfaba65b7433"},
   "makeup": {:hex, :makeup, "1.0.1", "82f332e461dc6c79dbd82fbe2a9c10d48ed07146f0a478286e590c83c52010b5", [:mix], [{:nimble_parsec, "~> 0.5.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "49736fe5b66a08d8575bf5321d716bac5da20c8e6b97714fec2bcd6febcfa1f8"},
   "makeup_elixir": {:hex, :makeup_elixir, "0.14.0", "cf8b7c66ad1cff4c14679698d532f0b5d45a3968ffbcbfd590339cb57742f1ae", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "d4b316c7222a85bbaa2fd7c6e90e37e953257ad196dc229505137c5e505e9eff"},
+  "meck": {:hex, :meck, "0.8.13", "ffedb39f99b0b99703b8601c6f17c7f76313ee12de6b646e671e3188401f7866", [:rebar3], [], "hexpm", "d34f013c156db51ad57cc556891b9720e6a1c1df5fe2e15af999c84d6cebeb1a"},
   "mime": {:hex, :mime, "1.3.1", "30ce04ab3175b6ad0bdce0035cba77bba68b813d523d1aac73d9781b4d193cf8", [:mix], [], "hexpm", "6cbe761d6a0ca5a31a0931bf4c63204bceb64538e664a8ecf784a9a6f3b875f1"},
+  "mock": {:hex, :mock, "0.3.6", "e810a91fabc7adf63ab5fdbec5d9d3b492413b8cda5131a2a8aa34b4185eb9b4", [:mix], [{:meck, "~> 0.8.13", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm", "bcf1d0a6826fb5aee01bae3d74474669a3fa8b2df274d094af54a25266a1ebd2"},
   "nimble_parsec": {:hex, :nimble_parsec, "0.5.3", "def21c10a9ed70ce22754fdeea0810dafd53c2db3219a0cd54cf5526377af1c6", [:mix], [], "hexpm", "589b5af56f4afca65217a1f3eb3fee7e79b09c40c742fddc1c312b3ac0b3399f"},
   "phoenix": {:hex, :phoenix, "1.4.17", "1b1bd4cff7cfc87c94deaa7d60dd8c22e04368ab95499483c50640ef3bd838d8", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.8.1 or ~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "3a8e5d7a3d76d452bb5fb86e8b7bd115f737e4f8efe202a463d4aeb4a5809611"},
   "phoenix_html": {:hex, :phoenix_html, "2.14.2", "b8a3899a72050f3f48a36430da507dd99caf0ac2d06c77529b1646964f3d563e", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "58061c8dfd25da5df1ea0ca47c972f161beb6c875cd293917045b92ffe1bf617"},

test/actions_test.exs

@@ -0,0 +1,143 @@
+defmodule ActionsTest do
+  use ExUnit.Case
+  use Phoenix.ConnTest
+
+  import Mock
+  alias Phoenix.Controller, as: PhoenixController
+
+  alias KaffyWeb.ResourceController
+
+  defmodule ActionsListAdmin do
+    @atom_action :test_action
+    @response %{id: "id"}
+
+    def index(_), do: []
+
+    def resource_actions(_conn) do
+      [
+        {@atom_action,
+         %{
+           name: "Test Action",
+           action: fn _, _ ->
+             {:ok, @response}
+           end
+         }}
+      ]
+    end
+
+    def list_actions(_conn) do
+      [
+        {@atom_action,
+         %{
+           name: "Test Action",
+           action: fn _, _, _ ->
+             {:ok, @response}
+           end
+         }}
+      ]
+    end
+  end
+
+  defmodule ActionsMapAdmin do
+    @string_action "test_action"
+    @response %{id: "id"}
+
+    def index(_), do: []
+
+    def resource_actions(_conn) do
+      %{
+        @string_action => %{
+          name: "Test Action",
+          action: fn _, _ ->
+            {:ok, @response}
+          end
+        }
+      }
+    end
+
+    def list_actions(_conn) do
+      %{
+        @string_action => %{
+          name: "Test Action",
+          action: fn _, _, _ ->
+            {:ok, @response}
+          end
+        }
+      }
+    end
+  end
+
+  defmodule FakeSchema do
+    use Ecto.Schema
+
+    schema "fake_schema" do
+    end
+
+    def changeset(fake, _attrs) do
+      fake
+    end
+  end
+
+  defmodule FakeRouter do
+    use Phoenix.Router
+    use Kaffy.Routes, scope: "/admin"
+  end
+
+  setup do
+    Application.put_env(:kaffy, :resources, fn _ ->
+      [
+        list: [
+          # a custom name for this context/section.
+          name: "list",
+          # this line used to be "schemas" in pre v0.9
+          resources: [
+            test: [schema: FakeSchema, admin: ActionsListAdmin]
+          ]
+        ],
+        map: [
+          name: "map",
+          resources: [
+            test: [schema: FakeSchema, admin: ActionsMapAdmin]
+          ]
+        ]
+      ]
+    end)
+
+    Application.put_env(:kaffy, :router, FakeRouter)
+
+    conn =
+      build_conn()
+      |> Plug.Test.init_test_session(%{})
+      |> PhoenixController.fetch_flash([])
+
+    [conn: conn]
+  end
+
+  test "resource controller accepts list of actions", %{conn: conn} do
+    with_mock Kaffy.ResourceQuery, fetch_resource: fn _, _, _ -> %{id: "id"} end do
+      result_conn =
+        ResourceController.single_action(conn, %{
+          "context" => "list",
+          "resource" => "test",
+          "action_key" => "test_action",
+          "id" => "id"
+        })
+
+      assert %{"success" => _} = get_flash(result_conn)
+    end
+  end
+
+  test "resource controller accepts map of actions", %{conn: conn} do
+    with_mock Kaffy.ResourceQuery, fetch_resource: fn _, _, _ -> %{id: "id"} end do
+      result_conn =
+        ResourceController.single_action(conn, %{
+          "context" => "map",
+          "resource" => "test",
+          "action_key" => "test_action",
+          "id" => "id"
+        })
+
+      assert %{"success" => _} = get_flash(result_conn)
+    end
+  end
+end

test/kaffy_test.exs

@@ -20,92 +20,75 @@ defmodule KaffyTest do
     assert is_nil(pet.name)
   end
 
-  describe "Kaffy.Resource" do
-    alias Kaffy.Resource
+  describe "Kaffy.ResourceSchema" do
+    alias Kaffy.ResourceSchema
 
     test "excluded_fields should return primary keys" do
-      assert [:id] == Resource.excluded_fields(Person)
-      assert [:id] == Resource.excluded_fields(Pet)
+      assert [:id] == ResourceSchema.excluded_fields(Person)
+      assert [:id] == ResourceSchema.excluded_fields(Pet)
     end
 
-    test "primary_keys/1 should return a list of primary keys" do
-      assert [:id] == Resource.primary_keys(Person)
-      assert [:id] == Resource.primary_keys(Pet)
+    test "primary_key/1 should return a primary key" do
+      assert [:id] == ResourceSchema.primary_key(Person)
+      assert [:id] == ResourceSchema.primary_key(Pet)
     end
 
     test "kaffy_field_name/2 should return the name of the field" do
-      assert "Address" == Resource.kaffy_field_name(nil, :address)
-      assert "Created_at" == Resource.kaffy_field_name(nil, :created_at)
+      assert "Address" == ResourceSchema.kaffy_field_name(nil, :address)
+      assert "Created At" == ResourceSchema.kaffy_field_name(nil, :created_at)
       person = %Person{name: "Abdullah"}
       f = {:status, %{name: "Yes"}}
-      assert "Yes" == Resource.kaffy_field_name(person, f)
+      assert "Yes" == ResourceSchema.kaffy_field_name(person, f)
       f = {:status, %{name: fn p -> String.upcase(p.name) end}}
-      assert "ABDULLAH" == Resource.kaffy_field_name(person, f)
+      assert "ABDULLAH" == ResourceSchema.kaffy_field_name(person, f)
       f = {:status, %{value: "something"}}
-      assert "Status" == Resource.kaffy_field_name(person, f)
+      assert "Status" == ResourceSchema.kaffy_field_name(person, f)
     end
 
     test "kaffy_field_value/2 should return the value of the field" do
       person = %Person{name: "Abdullah"}
-      assert "Abdullah" == Resource.kaffy_field_value(person, :name)
+      assert "Abdullah" == ResourceSchema.kaffy_field_value(person, :name)
       field = {:name, %{value: "Esmail"}}
-      assert "Esmail" == Resource.kaffy_field_value(person, field)
+      assert "Esmail" == ResourceSchema.kaffy_field_value(nil, person, field)
       field = {:name, %{value: fn p -> "Mr. #{p.name}" end}}
-      assert "Mr. Abdullah" == Resource.kaffy_field_value(person, field)
+      assert "Mr. Abdullah" == ResourceSchema.kaffy_field_value(nil, person, field)
       field = {:name, %{name: fn p -> "Mr. #{p.name}" end}}
-      assert "Abdullah" == Resource.kaffy_field_value(person, field)
-    end
-
-    test "fields/1 should return all the fields of a schema without associations" do
-      fields = Resource.fields(Person)
-      assert is_list(fields)
-      assert Enum.all?(fields, fn f -> is_atom(f) end)
-      [first | _] = fields
-      assert first == :id
-      assert length(fields) == 6
+      assert "Abdullah" == ResourceSchema.kaffy_field_value(nil, person, field)
     end
 
     test "associations/1 must return all associations for the schema" do
-      associations = Resource.associations(Person)
+      associations = ResourceSchema.associations(Person)
       assert [:pets] == associations
-      pet_assoc = Resource.associations(Pet)
+      pet_assoc = ResourceSchema.associations(Pet)
       assert [:person] == pet_assoc
     end
 
     test "association/1 must return information about the association" do
-      person_assoc = Resource.association(Person, :pets)
+      person_assoc = ResourceSchema.association(Person, :pets)
       assert Ecto.Association.Has == person_assoc.__struct__
       assert person_assoc.cardinality == :many
       assert person_assoc.queryable == Pet
 
-      pet_assoc = Resource.association(Pet, :person)
+      pet_assoc = ResourceSchema.association(Pet, :person)
       assert Ecto.Association.BelongsTo == pet_assoc.__struct__
       assert pet_assoc.cardinality == :one
       assert pet_assoc.queryable == Person
     end
 
     test "association_schema/2 must return the schema of the association" do
-      assert Pet == Resource.association_schema(Person, :pets)
-      assert Person == Resource.association_schema(Pet, :person)
-    end
-
-    test "form_label/2 should return a label tag" do
-      {:safe, label_tag} = Resource.form_label(:user, "My name")
-      assert is_list(label_tag)
-      label_string = to_string(label_tag)
-      assert String.contains?(label_string, "<label")
-      assert String.contains?(label_string, "user")
-      assert String.contains?(label_string, "My name")
+      assert Pet == ResourceSchema.association_schema(Person, :pets)
+      assert Person == ResourceSchema.association_schema(Pet, :person)
     end
   end
 
   describe "Kaffy.ResourceAdmin" do
     alias Kaffy.ResourceAdmin
 
-    test "index/1 should return a keyword list of fields and their values" do
-      assert Kaffy.Resource.fields(Person) == ResourceAdmin.index(schema: Person)
-      custom_index = ResourceAdmin.index(schema: Person, admin: PersonAdmin)
-      assert [:name, :married] == Keyword.keys(custom_index)
-    end
+    # [Qizot] I don't know if this test should be valid anymore if associations are allowed
+    # test "index/1 should return a keyword list of fields and their values" do
+    #   assert Kaffy.ResourceSchema.fields(Person) == ResourceAdmin.index(schema: Person)
+    #   custom_index = ResourceAdmin.index(schema: Person, admin: PersonAdmin)
+    #   assert [:name, :married] == Keyword.keys(custom_index)
+    # end
   end
 end