├── .github
├── FUNDING.yml
├── ISSUE_TEMPLATE
│ └── bug_report.md
└── workflows
│ └── ci.yml
├── .dockerignore
├── lib
├── live_admin
│ ├── gettext.ex
│ ├── session
│ │ ├── store.ex
│ │ └── agent.ex
│ ├── components
│ │ ├── home.ex
│ │ ├── layout
│ │ │ ├── app.html.heex
│ │ │ └── layout.html.heex
│ │ ├── home
│ │ │ └── content.ex
│ │ ├── session.ex
│ │ ├── resource
│ │ │ ├── form
│ │ │ │ ├── array_input.ex
│ │ │ │ ├── map_input.ex
│ │ │ │ └── search_select.ex
│ │ │ ├── view.ex
│ │ │ ├── form.ex
│ │ │ └── index.ex
│ │ ├── nav.ex
│ │ ├── session
│ │ │ └── content.ex
│ │ └── container.ex
│ ├── session.ex
│ ├── error_helpers.ex
│ ├── view.ex
│ ├── components.ex
│ ├── router.ex
│ └── resource.ex
├── application.ex
└── live_admin.ex
├── assets
├── postcss.config.js
├── tailwind.config.js
├── package.json
├── esbuild.js
├── js
│ └── app.js
└── css
│ └── app.css
├── .formatter.exs
├── Dockerfile
├── dev
├── readme_generator.ex
├── gettext
│ └── tr
│ │ └── LC_MESSAGES
│ │ └── default.po
└── initdb
│ └── structure.sql
├── config
└── config.exs
├── docker-compose.yml
├── .gitignore
├── test
├── live_admin_test.exs
├── test_helper.exs
└── live_admin
│ └── components
│ └── container_test.exs
├── LICENSE.md
├── dist
└── css
│ ├── default_overrides.css
│ └── app.css
├── mix.exs
├── README.md
├── README.md.eex
├── mix.lock
└── dev.exs
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: [tfwright]
2 |
--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
1 | _build
2 | deps
3 | assets/node_modules
4 | test
5 |
--------------------------------------------------------------------------------
/lib/live_admin/gettext.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.Gettext do
2 | use Gettext, otp_app: :live_admin
3 | end
4 |
--------------------------------------------------------------------------------
/assets/postcss.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | plugins: {
3 | tailwindcss: {},
4 | autoprefixer: {},
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/.formatter.exs:
--------------------------------------------------------------------------------
1 | # Used by "mix format"
2 | [
3 | plugins: [Phoenix.LiveView.HTMLFormatter],
4 | inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{heex,ex,exs}"]
5 | ]
6 |
--------------------------------------------------------------------------------
/assets/tailwind.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | content: [
3 | './css/**/*.css',
4 | '../lib/live_admin/**/*.*ex',
5 | ],
6 | theme: {},
7 | variants: {},
8 | plugins: []
9 | };
10 |
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM bitwalker/alpine-elixir-phoenix:1.13
2 |
3 | ADD mix.exs mix.lock ./
4 | RUN mix do deps.get, deps.compile
5 |
6 | ADD assets assets/
7 | RUN npm --prefix assets install
8 | RUN npm --prefix assets run build
9 |
--------------------------------------------------------------------------------
/dev/readme_generator.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.READMECompiler do
2 | use Docout, output_path: "README.md"
3 |
4 | @impl true
5 | def format(_) do
6 | File.cwd!()
7 | |> Path.join("./README.md.eex")
8 | |> File.read!()
9 | |> EEx.eval_string(app_version: Application.spec(:live_admin)[:vsn])
10 | end
11 | end
12 |
--------------------------------------------------------------------------------
/lib/live_admin/session/store.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.Session.Store do
2 | @type session :: LiveAdmin.Session.t()
3 | @type conn :: Plug.Conn.t()
4 | @type id :: String.t()
5 | @type live_session :: map()
6 |
7 | @callback init!(conn) :: id
8 | @callback load!(id) :: session
9 | @callback persist!(session) :: :ok
10 | end
11 |
--------------------------------------------------------------------------------
/lib/application.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.Application do
2 | use Application
3 |
4 | def start(_type, _args) do
5 | opts = [strategy: :one_for_one, name: LiveAdmin.Supervisor]
6 | Supervisor.start_link(children(), opts)
7 | end
8 |
9 | defp children do
10 | [
11 | {LiveAdmin.Session.Agent, %{}},
12 | {Task.Supervisor, name: LiveAdmin.Task.Supervisor}
13 | ]
14 | end
15 | end
16 |
--------------------------------------------------------------------------------
/lib/live_admin/components/home.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.Components.Home do
2 | use Phoenix.LiveView
3 |
4 | @impl true
5 | def mount(_params, %{"components" => %{home: mod}, "title" => title}, socket) do
6 | {:ok,
7 | assign(socket,
8 | mod: mod,
9 | title: title
10 | )}
11 | end
12 |
13 | @impl true
14 | def render(assigns) do
15 | ~H"""
16 | <.live_component module={@mod} id="content" />
17 | """
18 | end
19 | end
20 |
--------------------------------------------------------------------------------
/config/config.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | config :phoenix, :json_library, Jason
4 | config :phoenix, :stacktrace_depth, 20
5 |
6 | config :logger, level: :warn
7 | config :logger, :console, format: "[$level] $message\n"
8 |
9 | config :phoenix, LiveAdmin.Endpoint,
10 | watchers: [
11 | node: ["esbuild.js", "--watch", cd: Path.expand("../assets", __DIR__)]
12 | ]
13 |
14 | config :docout,
15 | app_name: :live_admin,
16 | formatters: [LiveAdmin.READMECompiler]
17 |
--------------------------------------------------------------------------------
/lib/live_admin/session.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.Session do
2 | use Ecto.Schema
3 |
4 | @type t() :: %__MODULE__{
5 | id: String.t(),
6 | prefix: String.t(),
7 | locale: String.t(),
8 | metadata: map()
9 | }
10 |
11 | @primary_key {:id, :string, autogenerate: false}
12 | embedded_schema do
13 | field(:prefix, :string)
14 | field(:locale, :string, default: "en")
15 | field(:metadata, :map, default: %{})
16 | end
17 | end
18 |
--------------------------------------------------------------------------------
/lib/live_admin/error_helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.ErrorHelpers do
2 | @moduledoc """
3 | Conveniences for translating and building error messages.
4 | """
5 |
6 | use Phoenix.HTML
7 |
8 | @doc """
9 | Generates tag for inlined form input errors.
10 | """
11 | def error_tag(form, field) do
12 | Enum.map(Keyword.get_values(form.errors, field), fn {desc, _details} ->
13 | content_tag(:span, desc,
14 | class: "resource__error",
15 | phx_feedback_for: input_id(form, field)
16 | )
17 | end)
18 | end
19 | end
20 |
--------------------------------------------------------------------------------
/lib/live_admin/components/layout/app.html.heex:
--------------------------------------------------------------------------------
1 |
2 | <%= Phoenix.Flash.get(@flash, :info) %>
3 |
4 | <.live_component
5 | id="nav"
6 | module={@nav_mod}
7 | title={@title}
8 | base_path={@base_path}
9 | resources={@resources}
10 | resource={assigns[:resource]}
11 | prefix={assigns[:prefix]}
12 | key={assigns[:key]}
13 | />
14 |
15 | <%= @inner_content %>
16 |
17 |
19 |
--------------------------------------------------------------------------------
/lib/live_admin/components/home/content.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.Components.Home.Content do
2 | use Phoenix.LiveComponent
3 |
4 | @impl true
5 | def render(assigns) do
6 | ~H"""
7 |
8 |
9 | This is the default LiveAdmin home page content.
10 |
11 | To use your own component, set the value of :home
12 | in the components option to a module that uses LiveComponent. LiveAdmin will render that component instead of this one in your app.
13 |
14 |
<%= @title %>
11 |
14 | <%= csrf_meta_tag() %>
15 |
26 |
27 |
28 | <%= for item <- @values do %>
29 | <%= item %>
30 | <% end %>
31 |
32 |
33 |
41 | <%= for {item, idx} <- Enum.with_index(@values) do %>
42 |
43 |
54 | <%= text_input(:form, :array,
55 | id: input_id(@form, @field) <> "_#{idx}",
56 | name: input_name(@form, @field) <> "[]",
57 | value: item,
58 | phx_debounce: 200
59 | ) %>
60 |
61 | <% end %>
62 |
72 |
28 |
29 | <%= @title %>
30 |
31 | <.link navigate={@base_path}><%= trans("Home") %>
32 |
33 |
34 | <.nav_group
35 | items={@nested_resources}
36 | base_path={@base_path}
37 | current_resource={assigns[:resource]}
38 | />
39 |
40 |
41 | <.link navigate={route_with_params(assigns, resource_path: "session")}>
42 | <%= trans("Session") %>
43 |
44 |
45 |
46 |
53 | <%= for {parent, children} <- Enum.sort(@items) do %>
54 | <%= if match?({_key, _resource}, parent) do %>
55 |
56 | <.link navigate={route_with_params(assigns, resource_path: elem(parent, 0))}>
57 | <%= resource_title(elem(parent, 1)) %>
58 |
59 |
60 | <% else %>
61 |
62 |
63 | <%= parent %>
64 | <.nav_group items={children} base_path={@base_path} current_resource={@current_resource} />
65 |
66 | <% end %>
67 | <% end %>
68 |
69 | """
70 | end
71 |
72 | defp open?(assigns, schema) do
73 | assigns.current_resource
74 | |> case do
75 | nil ->
76 | true
77 |
78 | resource ->
79 | resource.__live_admin_config__(:schema)
80 | |> Module.split()
81 | |> Enum.drop(-1)
82 | |> Enum.member?(schema)
83 | end
84 | end
85 | end
86 |
--------------------------------------------------------------------------------
/lib/live_admin/components/session/content.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.Components.Session.Content do
2 | use Phoenix.LiveComponent
3 | use Phoenix.HTML
4 |
5 | import LiveAdmin, only: [trans: 1]
6 |
7 | alias Ecto.Changeset
8 | alias LiveAdmin.Components.Container.Form.MapInput
9 |
10 | @impl true
11 | def render(assigns) do
12 | ~H"""
13 |
14 |
15 |
16 | <%= trans("Session") %>
17 |
18 |
19 |
20 | <.form
21 | :let={f}
22 | for={@changeset}
23 | as={:session}
24 | phx-submit={:save}
25 | phx-target={@myself}
26 | phx-change={:validate}
27 | class="resource__form"
28 | >
29 |
30 | <%= label(f, :id, trans("id"), class: "field__label") %>
31 | <%= textarea(f, :id, rows: 1, class: "field__text", disabled: true) %>
32 |
33 |
34 | <%= label(f, :prefix, trans("prefix"), class: "field__label") %>
35 | <%= textarea(f, :prefix, rows: 1, class: "field__text", disabled: true) %>
36 |
37 |
38 | <%= label(f, :locale, trans("locale"), class: "field__label") %>
39 | <%= textarea(f, :locale, rows: 1, class: "field__text", disabled: true) %>
40 |
41 |
42 | <%= label(f, :metadata, trans("metadata"), class: "field__label") %>
43 | <.live_component module={MapInput} id="metadata" form={f} field={:metadata} />
44 |
45 |
46 | <%= submit(trans("Save"), class: "resource__action--btn") %>
47 |
48 |
49 |
39 |
40 | <%= @form |> input_value(@field) |> inspect() %>
41 |
42 |
50 |
51 | <%= for {idx, %{"key" => k, "value" => v}} <- Enum.sort(@values) do %>
52 |
77 | <% end %>
78 |
88 |
89 |
25 | <%= if @selected_option do %>
26 | <%= record_label(@selected_option, @resource) %>
27 | <% else %>
28 | <%= trans("None") %>
29 | <% end %>
30 |
31 | """
32 | end
33 |
34 | @impl true
35 | def render(assigns) do
36 | ~H"""
37 |
38 | <%= hidden_input(@form, @field,
39 | disabled: @disabled,
40 | value: if(@selected_option, do: @selected_option.id)
41 | ) %>
42 | <%= if @selected_option do %>
43 |
48 | <%= record_label(@selected_option, @resource) %>
49 | <% else %>
50 |
51 |
"_search_select"}
54 | disabled={@disabled}
55 | placeholder={trans("Search")}
56 | autocomplete="off"
57 | phx-focus="load_options"
58 | phx-keyup="load_options"
59 | phx-target={@myself}
60 | phx-debounce={200}
61 | />
62 |
63 |
64 |
65 | <%= if Enum.empty?(@options) do %>
66 | <%= trans("No options") %>
67 | <% end %>
68 | <%= for option <- @options, option.id != input_value(@form, @field) do %>
69 |
70 |
76 | <%= record_label(option, @resource) %>
77 |
78 |
79 | <% end %>
80 |
81 |
82 |
83 |
84 | <% end %>
85 |
19 | <%= if @orientation == :up do %>
20 | <.list items={@items} inner_block={@inner_block} />
21 | <% end %>
22 |
26 | <%= @label %>
27 |
28 | <%= if @orientation == :down do %>
29 | <.list items={@items} inner_block={@inner_block} />
30 | <% end %>
31 |
32 | """
33 | end
34 |
35 | def embed(assigns) do
36 | ~H"""
37 | "_container"} class="embed__group" phx-hook="EmbedComponent">
38 | <%= unless @disabled do %>
39 | <.inputs_for :let={embed_form} field={@form[@field]} skip_hidden={true}>
40 |
41 | <%= if match?({_, _, %{cardinality: :many}}, @type) do %>
42 |
"[]"}
45 | value={embed_form.index}
46 | class="embed__index"
47 | phx-page-loading
48 | />
49 |
"[]"}
52 | value={embed_form.index}
53 | class="embed__drop"
54 | phx-page-loading
55 | />
56 |
57 | <%= if embed_form.index > 0 do %>
58 |
64 | <% end %>
65 | <%= if embed_form.index < Enum.count(List.wrap(input_value(@form, @field))) - 1 do %>
66 |
72 | <% end %>
73 | <% else %>
74 |
75 |
76 | <% end %>
77 |
78 | <%= for {field, type, _} <- embed_fields(@type) do %>
79 |
92 |
93 |
94 | <%= if match?({_, _, %{cardinality: :many}}, @type) || !input_value(@form, @field) do %>
95 |
"[]"}
98 | class="embed__sort"
99 | phx-page-loading
100 | />
101 |
102 | <% end %>
103 | <% else %>
104 |
<%= @form |> input_value(@field) |> inspect() %>
105 | <% end %>
106 |
113 |
114 |
115 | <%= for item <- @items do %>
116 | <%= render_slot(@inner_block, item) %>
117 | <% end %>
118 |
119 |
120 |
<%= trans("No record found") %>
18 | """
19 | end
20 |
21 | @impl true
22 | def render(assigns) do
23 | ~H"""
24 |
25 |
26 |
27 | <%= for {field, type, _} <- Resource.fields(@resource) do %>
28 | <% assoc_resource =
29 | LiveAdmin.associated_resource(
30 | @resource.__live_admin_config__(:schema),
31 | field,
32 | @resources
33 | ) %>
34 | <% label = Resource.render(@record, field, @resource, assoc_resource, @session) %>
35 | <%= trans(humanize(field)) %>
36 |
37 | <%= if assoc_resource && Map.fetch!(@record, field) do %>
38 | <.link
39 | class="field__assoc--link"
40 | target="_blank"
41 | navigate={
42 | route_with_params(assigns,
43 | resource_path: elem(assoc_resource, 0),
44 | segments: [Map.fetch!(@record, field)]
45 | )
46 | }
47 | >
48 | <%= label %>
49 |
50 | <% else %>
51 | <%= label %>
52 | <% end %>
53 |
54 | <% end %>
55 |
56 |
57 | <%= if @resource.__live_admin_config__(:delete_with) != false do %>
58 | <.link
59 | navigate={route_with_params(assigns, segments: [:edit, @record])}
60 | class="resource__action--btn"
61 | >
62 | <%= trans("Edit") %>
63 |
64 | <% end %>
65 | <%= if @resource.__live_admin_config__(:delete_with) != false do %>
66 |
73 | <%= trans("Delete") %>
74 |
75 | <% end %>
76 | <.dropdown
77 | :let={action}
78 | orientation={:up}
79 | label={trans("Run action")}
80 | items={@resource.__live_admin_config__(:actions)}
81 | disabled={Enum.empty?(@resource.__live_admin_config__(:actions))}
82 | >
83 |
89 | <%= action |> to_string() |> humanize() %>
90 |
91 |
92 |
93 |
94 |
LiveAdmin |
28 | end
29 |
30 | test "links to resource", %{response: response} do
31 | assert response |> Floki.find("a[href='/user']") |> Enum.any?()
32 | end
33 | end
34 |
35 | describe "list resource" do
36 | setup %{conn: conn} do
37 | Repo.insert!(%User{})
38 | {:ok, view, _html} = live(conn, "/user")
39 | %{view: view}
40 | end
41 |
42 | test "links to new form", %{view: view} do
43 | assert {_, {:live_redirect, %{to: "/user/new"}}} =
44 | view
45 | |> element("a[href='/user/new'")
46 | |> render_click()
47 | end
48 |
49 | test "deletes record", %{view: view} do
50 | view
51 | |> element("#list")
52 | |> render_hook("delete", %{ids: []})
53 |
54 | assert_redirected(view, "/user")
55 | end
56 |
57 | test "runs configured action on selected records", %{view: view} do
58 | view
59 | |> element("#list")
60 | |> render_hook("action", %{action: "user_action", ids: []})
61 |
62 | assert_redirected(view, "/user")
63 | end
64 | end
65 |
66 | describe "list resource with search param" do
67 | setup %{conn: conn} do
68 | Repo.insert!(%User{name: "Tom"})
69 | {:ok, view, html} = live(conn, "/user?s=fred")
70 | %{view: view, response: html}
71 | end
72 |
73 | test "filters results", %{view: view} do
74 | assert render(view) =~ "0 total"
75 | end
76 |
77 | test "clears search", %{view: view} do
78 | view
79 | |> element("button[phx-click='search']")
80 | |> render_click()
81 |
82 | assert render(view) =~ "1 total"
83 | end
84 | end
85 |
86 | describe "list resource with prefix param" do
87 | setup %{conn: conn} do
88 | Repo.insert!(%User{name: "Tom"}, prefix: "alt")
89 | {:ok, view, _} = live(conn, "/user?prefix=alt")
90 | %{view: view}
91 | end
92 |
93 | test "renders result from prefix", %{view: view} do
94 | assert render(view) =~ "1 total"
95 | end
96 | end
97 |
98 | describe "list resource with prefix in session" do
99 | setup %{conn: conn} do
100 | Repo.insert!(%User{name: "Tom"}, prefix: "alt")
101 |
102 | stub(LiveAdminTest.MockSession, :load!, fn _customer_id ->
103 | %LiveAdmin.Session{prefix: "alt"}
104 | end)
105 |
106 | {:ok, view, _} = live(conn, "/user")
107 | %{view: view}
108 |
109 | %{view: view}
110 | end
111 |
112 | test "renders results from prefix", %{view: view} do
113 | assert render(view) =~ "1 total"
114 | end
115 | end
116 |
117 | describe "new parent resource" do
118 | setup %{conn: conn} do
119 | {:ok, view, html} = live(conn, "/user/new")
120 | %{response: html, view: view}
121 | end
122 |
123 | test "includes castable form field", %{response: response} do
124 | assert response
125 | |> Floki.find("textarea[name='params[name]']")
126 | |> Enum.any?()
127 | end
128 |
129 | test "handles form change", %{view: view} do
130 | assert view
131 | |> element(".resource__form")
132 | |> render_change()
133 | end
134 |
135 | test "persists all form changes", %{view: view} do
136 | response =
137 | view
138 | |> element(".resource__form")
139 | |> render_change(%{
140 | "params" => %{"name" => "test name", "settings" => %{"some_option" => "test option"}}
141 | })
142 |
143 | assert response =~ "test option"
144 | assert response =~ "test name"
145 | end
146 |
147 | test "creates user on form submit", %{view: view} do
148 | view
149 | |> form(".resource__form", %{params: %{name: "test"}})
150 | |> render_submit()
151 |
152 | assert [%{}] = Repo.all(User)
153 | end
154 | end
155 |
156 | describe "new child resource" do
157 | setup %{conn: conn} do
158 | {:ok, view, html} = live(conn, "/live_admin_test_post/new")
159 | %{response: html, view: view}
160 | end
161 |
162 | test "includes search select field", %{response: response} do
163 | assert response
164 | |> Floki.find("#params_user_id_search_select")
165 | |> Enum.any?()
166 | end
167 |
168 | test "search select responds to focus", %{view: view} do
169 | view
170 | |> element("#params_user_id_search_select")
171 | |> render_focus(%{value: "xxx"})
172 | end
173 | end
174 |
175 | describe "edit resource" do
176 | setup %{conn: conn} do
177 | user = Repo.insert!(%User{})
178 | {:ok, view, html} = live(conn, "/user/edit/#{user.id}")
179 | %{response: html, view: view, user: user}
180 | end
181 |
182 | test "updates record on submit", %{view: view, user: user} do
183 | view
184 | |> form(".resource__form", %{params: %{name: "test"}})
185 | |> render_submit()
186 |
187 | assert %{name: "test"} = Repo.get!(User, user.id)
188 | end
189 |
190 | test "disables immutable fields", %{response: response} do
191 | assert ["disabled"] ==
192 | response
193 | |> Floki.find("textarea[name='params[encrypted_password]']")
194 | |> Floki.attribute("disabled")
195 | end
196 | end
197 |
198 | describe "edit resource with embed" do
199 | setup %{conn: conn} do
200 | user = Repo.insert!(%User{settings: %{}})
201 | {:ok, view, html} = live(conn, "/user/edit/#{user.id}")
202 | %{response: html, view: view}
203 | end
204 |
205 | test "includes embed form field", %{response: response} do
206 | assert response
207 | |> Floki.find("textarea[name='params[settings][some_option]']")
208 | |> Enum.any?()
209 | end
210 | end
211 |
212 | describe "edit resource with plural embed with multiple entries" do
213 | setup %{conn: conn} do
214 | post = Repo.insert!(%Post{title: "test", previous_versions: [%Version{}, %Version{}]})
215 | {:ok, view, html} = live(conn, "/live_admin_test_post/edit/#{post.id}")
216 | %{response: html, view: view}
217 | end
218 |
219 | test "includes multiple embed fields", %{response: response} do
220 | assert 2 =
221 | response
222 | |> Floki.find(".embed__item")
223 | |> Enum.count()
224 | end
225 | end
226 |
227 | describe "edit resource with map field with map value" do
228 | setup %{conn: conn} do
229 | user =
230 | Repo.insert!(%User{
231 | settings: %{metadata: %{map_key: %{}}}
232 | })
233 |
234 | {:ok, view, html} = live(conn, "/user/edit/#{user.id}")
235 | %{response: html, view: view}
236 | end
237 |
238 | test "disables field", %{response: response} do
239 | assert response
240 | |> Floki.find(".resource__action--disabled")
241 | |> Enum.any?()
242 | end
243 | end
244 |
245 | describe "view resource" do
246 | setup %{conn: conn} do
247 | user = Repo.insert!(%User{})
248 | {:ok, view, html} = live(conn, "/user/#{user.id}")
249 | %{response: html, view: view, user: user}
250 | end
251 |
252 | test "deletes record", %{view: view} do
253 | view
254 | |> element("button", "Delete")
255 | |> render_click()
256 |
257 | assert_redirected(view, "/user")
258 | end
259 | end
260 |
261 | describe "view resource with associated resource" do
262 | setup %{conn: conn} do
263 | user = Repo.insert!(%User{})
264 | post = Repo.insert!(%Post{title: "test", user: user})
265 | {:ok, _, html} = live(conn, "/live_admin_test_post/#{post.id}")
266 | %{response: html, user: user}
267 | end
268 |
269 | test "links to user", %{response: response, user: user} do
270 | assert response
271 | |> Floki.find("a[href='/user/#{user.id}']")
272 | |> Enum.any?()
273 | end
274 | end
275 | end
276 |
--------------------------------------------------------------------------------
/lib/live_admin/components/container.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.Components.Container do
2 | use Phoenix.LiveView
3 | use Phoenix.HTML
4 |
5 | import LiveAdmin,
6 | only: [
7 | resource_title: 1,
8 | route_with_params: 1,
9 | route_with_params: 2,
10 | trans: 1
11 | ]
12 |
13 | import LiveAdmin.Components
14 |
15 | alias LiveAdmin.Resource
16 | alias Phoenix.LiveView.JS
17 |
18 | @impl true
19 | def mount(_params, %{"components" => components}, socket) do
20 | socket =
21 | assign(socket,
22 | default_mod: Map.fetch!(components, socket.assigns.live_action),
23 | loading: !connected?(socket)
24 | )
25 |
26 | Process.send_after(self(), :clear_flash, 2000)
27 |
28 | {:ok, socket}
29 | end
30 |
31 | @impl true
32 | def handle_info(:clear_flash, socket) do
33 | {:noreply, clear_flash(socket)}
34 | end
35 |
36 | @impl true
37 | def handle_params(
38 | params = %{"record_id" => id},
39 | uri,
40 | socket = %{assigns: %{live_action: action, loading: false}}
41 | )
42 | when action in [:edit, :view] do
43 | socket =
44 | socket
45 | |> assign_resource_info(uri)
46 | |> assign_mod()
47 | |> assign_repo()
48 | |> assign_prefix(params)
49 |
50 | record =
51 | Resource.find(id, socket.assigns.resource, socket.assigns.prefix, socket.assigns.repo)
52 |
53 | socket = assign(socket, record: record)
54 |
55 | {:noreply, socket}
56 | end
57 |
58 | @impl true
59 | def handle_params(params, uri, socket = %{assigns: %{live_action: :list, loading: false}}) do
60 | socket =
61 | socket
62 | |> assign(page: String.to_integer(params["page"] || "1"))
63 | |> assign(sort_attr: String.to_existing_atom(params["sort-attr"] || "id"))
64 | |> assign(sort_dir: String.to_existing_atom(params["sort-dir"] || "asc"))
65 | |> assign(search: params["s"])
66 | |> assign_resource_info(uri)
67 | |> assign_mod()
68 | |> assign_repo()
69 | |> assign_prefix(params)
70 |
71 | {:noreply, socket}
72 | end
73 |
74 | @impl true
75 | def handle_params(params, uri, socket = %{assigns: %{live_action: :new}}),
76 | do:
77 | {:noreply,
78 | socket
79 | |> assign_resource_info(uri)
80 | |> assign_mod()
81 | |> assign_repo()
82 | |> assign_prefix(params)}
83 |
84 | def handle_params(_, _, socket), do: {:noreply, socket}
85 |
86 | @impl true
87 | def handle_event("set_locale", %{"locale" => locale}, socket) do
88 | new_session = Map.put(socket.assigns.session, :locale, locale)
89 |
90 | LiveAdmin.session_store().persist!(new_session)
91 |
92 | {:noreply, assign(socket, :session, new_session)}
93 | end
94 |
95 | def render(assigns = %{loading: true}), do: ~H"
96 | "
97 |
98 | @impl true
99 | def render(assigns) do
100 | ~H"""
101 |
102 |
103 | <%= resource_title(@resource) %>
104 |
105 |
106 |
107 |
108 | <.link
109 | navigate={route_with_params(assigns, params: [prefix: @prefix])}
110 | class="resource__action--btn"
111 | >
112 | <%= trans("List") %>
113 |
114 | <%= if @resource.__live_admin_config__(:create_with) != false do %>
115 | <.link
116 | navigate={route_with_params(assigns, segments: ["new"], params: [prefix: @prefix])}
117 | class="resource__action--btn"
118 | >
119 | <%= trans("New") %>
120 |
121 | <% else %>
122 |
123 | <%= trans("New") %>
124 |
125 | <% end %>
126 | <.dropdown
127 | :let={task}
128 | label={trans("Run task")}
129 | items={get_task_keys(@resource)}
130 | disabled={@resource |> get_task_keys() |> Enum.empty?()}
131 | >
132 |
138 | <%= task |> to_string() |> humanize() %>
139 |
140 |
141 | <%= if Enum.any?(@prefix_options) do %>
142 | <.dropdown
143 | :let={prefix}
144 | id="prefix-select"
145 | label={@prefix || trans("Set prefix")}
146 | items={[nil] ++ Enum.filter(@prefix_options, &(to_string(&1) != @prefix))}
147 | >
148 | <.link navigate={route_with_params(assigns, params: [prefix: prefix])}>
149 | <%= prefix || trans("clear") %>
150 |
151 |
152 | <% end %>
153 | <%= if LiveAdmin.use_i18n? do %>
154 | <.dropdown
155 | :let={locale}
156 | id="locale-select"
157 | label={@session.locale || "Set locale"}
158 | items={
159 | Enum.filter(
160 | LiveAdmin.gettext_backend().locales(),
161 | &(to_string(&1) != @session.locale)
162 | )
163 | }
164 | >
165 |
169 | <%= locale %>
170 |
171 |
172 | <% end %>
173 |
174 |
175 |
<%= trans("No record found") %>
39 | """
40 | end
41 |
42 | @impl true
43 | def render(assigns) do
44 | ~H"""
45 |
46 | <.form
47 | :let={f}
48 | for={@changeset}
49 | as={:params}
50 | phx-change="validate"
51 | phx-submit={@action}
52 | phx-target={@myself}
53 | class="resource__form"
54 | >
55 | <%= for {field, type, opts} <- Resource.fields(@resource) do %>
56 | <.field
57 | field={field}
58 | type={type}
59 | form={f}
60 | immutable={Keyword.get(opts, :immutable, false)}
61 | resource={@resource}
62 | resources={@resources}
63 | session={@session}
64 | prefix={@prefix}
65 | repo={@repo}
66 | />
67 | <% end %>
68 |
82 |
83 |
148 | <%= label(@form, @field, @field |> humanize() |> trans(), class: "field__label") %>
149 | <%= if supported_type?(@type) do %>
150 | <.input
151 | form={@form}
152 | type={@type}
153 | field={@field}
154 | disabled={@immutable}
155 | resource={@resource}
156 | resources={@resources}
157 | session={@session}
158 | prefix={@prefix}
159 | repo={@repo}
160 | />
161 | <% else %>
162 | <%= textarea(@form, @field,
163 | rows: 1,
164 | disabled: true,
165 | value: @form |> input_value(@field) |> inspect()
166 | ) %>
167 | <% end %>
168 | <%= error_tag(@form, @field) %>
169 |
170 | """
171 | end
172 |
173 | defp input(assigns = %{type: {_, Ecto.Embedded, _}}) do
174 | ~H"""
175 | <.embed
176 | id={input_id(@form, @field)}
177 | type={@type}
178 | disabled={@disabled}
179 | form={@form}
180 | field={@field}
181 | resource={@resource}
182 | resources={@resource}
183 | session={@session}
184 | prefix={@prefix}
185 | repo={@repo}
186 | />
187 | """
188 | end
189 |
190 | defp input(assigns = %{type: id}) when id in [:id, :binary_id] do
191 | assigns =
192 | assign(
193 | assigns,
194 | :associated_resource,
195 | associated_resource(
196 | assigns.resource.__live_admin_config__(:schema),
197 | assigns.field,
198 | assigns.resources,
199 | :resource
200 | )
201 | )
202 |
203 | ~H"""
204 | <%= if @associated_resource do %>
205 | <%= unless @form.data |> Ecto.primary_key() |> Keyword.keys() |> Enum.member?(@field) do %>
206 | <.live_component
207 | module={SearchSelect}
208 | id={input_id(@form, @field)}
209 | form={@form}
210 | field={@field}
211 | disabled={@disabled}
212 | resource={@associated_resource}
213 | session={@session}
214 | prefix={@prefix}
215 | repo={@repo}
216 | />
217 | <% else %>
218 |
219 | <%= number_input(@form, @field, disabled: @disabled) %>
220 |
221 | <% end %>
222 | <% else %>
223 | <%= textarea(@form, @field, rows: 1, disabled: @disabled) %>
224 | <% end %>
225 | """
226 | end
227 |
228 | defp input(assigns = %{type: {:array, :string}}) do
229 | ~H"""
230 | <.live_component
231 | module={ArrayInput}
232 | id={input_id(@form, @field)}
233 | form={@form}
234 | field={@field}
235 | disabled={@disabled}
236 | />
237 | """
238 | end
239 |
240 | defp input(assigns = %{type: :map}) do
241 | ~H"""
242 | <.live_component
243 | module={MapInput}
244 | id={input_id(@form, @field)}
245 | form={@form}
246 | field={@field}
247 | disabled={@disabled}
248 | />
249 | """
250 | end
251 |
252 | defp input(assigns = %{type: :string}) do
253 | ~H"""
254 | <%= textarea(@form, @field, rows: 1, disabled: @disabled, phx_debounce: 200) %>
255 | """
256 | end
257 |
258 | defp input(assigns = %{type: :boolean}) do
259 | ~H"""
260 |
261 | <%= for option <- ["true", "false"] do %>
262 | <%= radio_button(@form, @field, option) %>
263 | <%= trans(option) %>
264 | <% end %>
265 | <%= radio_button(@form, @field, "", checked: input_value(@form, @field) in ["", nil]) %>
266 | <%= trans("nil") %>
267 |
268 | """
269 | end
270 |
271 | defp input(assigns = %{type: :date}) do
272 | ~H"""
273 | <%= date_input(@form, @field, disabled: @disabled) %>
274 | """
275 | end
276 |
277 | defp input(assigns = %{type: number}) when number in [:integer, :id] do
278 | ~H"""
279 |
280 | <%= number_input(@form, @field, disabled: @disabled, phx_debounce: 200) %>
281 |
282 | """
283 | end
284 |
285 | defp input(assigns = %{type: :float}) do
286 | ~H"""
287 |
288 | <%= number_input(@form, @field, disabled: @disabled, step: "any", phx_debounce: 200) %>
289 |
290 | """
291 | end
292 |
293 | defp input(assigns = %{type: type}) when type in [:naive_datetime, :utc_datetime] do
294 | ~H"""
295 |
296 | <%= datetime_local_input(@form, @field, disabled: @disabled) %>
297 |
298 | """
299 | end
300 |
301 | defp input(assigns = %{type: {_, Ecto.Enum, %{mappings: mappings}}}) do
302 | assigns = assign(assigns, :mappings, mappings)
303 |
304 | ~H"""
305 | <%= select(@form, @field, [nil | Keyword.keys(@mappings)], disabled: @disabled) %>
306 | """
307 | end
308 |
309 | defp input(assigns = %{type: {:array, {_, Ecto.Enum, %{mappings: mappings}}}}) do
310 | assigns = assign(assigns, :mappings, mappings)
311 |
312 | ~H"""
313 |
314 | <%= hidden_input(@form, @field, name: input_name(@form, @field) <> "[]", value: nil) %>
315 | <%= for option <- Keyword.keys(@mappings) do %>
316 | <%= checkbox(@form, @field,
317 | name: input_name(@form, @field) <> "[]",
318 | checked_value: option,
319 | value:
320 | @form
321 | |> input_value(@field)
322 | |> Kernel.||([])
323 | |> Enum.find(&(to_string(&1) == to_string(option))),
324 | unchecked_value: "",
325 | hidden_input: false,
326 | disabled: @disabled,
327 | id: input_id(@form, @field) <> to_string(option)
328 | ) %>
329 | to_string(option)}>
330 | <%= trans(to_string(option)) %>
331 |
332 | <% end %>
333 |
334 | """
335 | end
336 |
337 | defp validate(resource, changeset, params, session) do
338 | resource
339 | |> Resource.change(changeset.data, params)
340 | |> Resource.validate(resource, session)
341 | end
342 |
343 | def enabled?(changeset, action, resource) do
344 | resource.__live_admin_config__(:"#{action}_with") != false && Enum.empty?(changeset.errors)
345 | end
346 | end
347 |
--------------------------------------------------------------------------------
/lib/live_admin/resource.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.Resource do
2 | @moduledoc """
3 | API for managing Ecto schemas and their individual record instances used internally by LiveAdmin.
4 |
5 | > #### `use LiveAdmin.Resource` {: .info}
6 | > This is required in any module that should act as a LiveAdmin Resource.
7 | > If the module is not an Ecto schema, then the `:schema` option must be passed.
8 | > Using this module will create a __live_admin_config__ module variable and 2 functions
9 | > to query it, __live_admin_config__/0 and __live_admin_config__/1. The former returns the entire
10 | > config while the latter will return a key if it exists, otherwise it will fallback
11 | > to either a global config for that key, or the key's default value.
12 |
13 | To customize UI behavior, the following options may also be used:
14 |
15 | * `title_with` - a binary, or MFA that returns a binary, used to identify the resource
16 | * `label_with` - a binary, or MFA that returns a binary, used to identify records
17 | * `list_with` - an atom or MFA that identifies the function that implements listing the resource
18 | * `create_with` - an atom or MFA that identifies the function that implements creating the resource (set to false to disable create)
19 | * `update_with` - an atom or MFA that identifies the function that implements updating a record (set to false to disable update)
20 | * `delete_with` - an atom or MFA that identifies the function that implements deleting a record (set to false to disable delete)
21 | * `validate_with` - an atom or MFA that identifies the function that implements validating a changed record
22 | * `render_with` - an atom or MFA that identifies the function that implements table field rendering logic
23 | * `hidden_fields` - a list of fields that should not be displayed in the UI
24 | * `immutable_fields` - a list of fields that should not be editable in forms
25 | * `actions` - list of atoms or MFAs that identify a function that operates on a record
26 | * `tasks` - list atoms or MFAs that identify a function that operates on a resource
27 | * `components` - keyword list of component module overrides for specific views (`:list`, `:new`, `:edit`, `:home`, `:nav`, `:session`, `:view`)
28 | * `ecto_repo` - Ecto repo to use when building queries for this resource
29 | """
30 |
31 | import Ecto.Query
32 | import LiveAdmin, only: [record_label: 2, parent_associations: 1]
33 |
34 | alias Ecto.Changeset
35 |
36 | @doc false
37 | defmacro __using__(opts) do
38 | quote bind_quoted: [opts: opts] do
39 | @__live_admin_config__ Keyword.put_new(opts, :schema, __MODULE__)
40 |
41 | def __live_admin_config__, do: @__live_admin_config__
42 |
43 | def __live_admin_config__(key) do
44 | @__live_admin_config__
45 | |> Keyword.get(key, Application.get_env(:live_admin, key))
46 | |> case do
47 | false -> false
48 | nil -> LiveAdmin.Resource.default_config_value(key)
49 | config -> config
50 | end
51 | end
52 | end
53 | end
54 |
55 | def render(record, field, resource, assoc_resource, session) do
56 | :render_with
57 | |> resource.__live_admin_config__()
58 | |> case do
59 | nil ->
60 | if assoc_resource do
61 | record_label(
62 | Map.fetch!(record, get_assoc_name!(resource.__live_admin_config__(:schema), field)),
63 | elem(assoc_resource, 1)
64 | )
65 | else
66 | record
67 | |> Map.fetch!(field)
68 | |> render_field()
69 | end
70 |
71 | {m, f, a} ->
72 | apply(m, f, [record, field, session] ++ a)
73 |
74 | f when is_atom(f) ->
75 | apply(resource, f, [record, field, session])
76 | end
77 | end
78 |
79 | def all(ids, resource, prefix, repo) do
80 | resource.__live_admin_config__(:schema)
81 | |> where([s], s.id in ^ids)
82 | |> repo.all(prefix: prefix)
83 | end
84 |
85 | def find!(id, resource, prefix, repo) do
86 | find(id, resource, prefix, repo) ||
87 | raise(Ecto.NoResultsError, queryable: resource.__live_admin_config__(:schema))
88 | end
89 |
90 | def find(id, resource, prefix, repo) do
91 | resource.__live_admin_config__(:schema)
92 | |> preload(^preloads(resource))
93 | |> repo.get(id, prefix: prefix)
94 | end
95 |
96 | def delete(record, resource, session, repo) do
97 | :delete_with
98 | |> resource.__live_admin_config__()
99 | |> case do
100 | nil ->
101 | repo.delete(record)
102 |
103 | {mod, func_name, args} ->
104 | apply(mod, func_name, [record, session] ++ args)
105 |
106 | name when is_atom(name) ->
107 | apply(resource, name, [record, session])
108 | end
109 | end
110 |
111 | def list(resource, opts, session, repo) do
112 | :list_with
113 | |> resource.__live_admin_config__()
114 | |> case do
115 | nil ->
116 | build_list(resource, opts, repo)
117 |
118 | {mod, func_name, args} ->
119 | apply(mod, func_name, [resource, opts, session] ++ args)
120 |
121 | name when is_atom(name) ->
122 | apply(resource, name, [opts, session])
123 | end
124 | end
125 |
126 | def change(resource, record \\ nil, params \\ %{})
127 |
128 | def change(resource, record, params) when is_struct(record) do
129 | build_changeset(record, resource, params)
130 | end
131 |
132 | def change(resource, nil, params) do
133 | :schema
134 | |> resource.__live_admin_config__()
135 | |> struct(%{})
136 | |> build_changeset(resource, params)
137 | end
138 |
139 | def create(resource, params, session, repo) do
140 | :create_with
141 | |> resource.__live_admin_config__()
142 | |> case do
143 | nil ->
144 | resource
145 | |> change(nil, params)
146 | |> repo.insert(prefix: session.prefix)
147 |
148 | {mod, func_name, args} ->
149 | apply(mod, func_name, [params, session] ++ args)
150 |
151 | name when is_atom(name) ->
152 | apply(resource, name, [params, session])
153 | end
154 | end
155 |
156 | def update(record, resource, params, session) do
157 | :update_with
158 | |> resource.__live_admin_config__()
159 | |> case do
160 | nil ->
161 | resource
162 | |> change(record, params)
163 | |> resource.__live_admin_config__(:ecto_repo).update()
164 |
165 | {mod, func_name, args} ->
166 | apply(mod, func_name, [record, params, session] ++ args)
167 |
168 | name when is_atom(name) ->
169 | apply(resource, name, [record, params, session])
170 | end
171 | end
172 |
173 | def validate(changeset, resource, session) do
174 | :validate_with
175 | |> resource.__live_admin_config__()
176 | |> case do
177 | nil -> changeset
178 | {mod, func_name, args} -> apply(mod, func_name, [changeset, session] ++ args)
179 | name when is_atom(name) -> apply(resource, name, [changeset, session])
180 | end
181 | |> Map.put(:action, :validate)
182 | end
183 |
184 | def fields(resource) do
185 | schema = resource.__live_admin_config__(:schema)
186 |
187 | Enum.flat_map(schema.__schema__(:fields), fn field_name ->
188 | :hidden_fields
189 | |> resource.__live_admin_config__()
190 | |> Enum.member?(field_name)
191 | |> case do
192 | false ->
193 | [
194 | {field_name, schema.__schema__(:type, field_name),
195 | [
196 | immutable:
197 | Enum.member?(resource.__live_admin_config__(:immutable_fields) || [], field_name)
198 | ]}
199 | ]
200 |
201 | true ->
202 | []
203 | end
204 | end)
205 | end
206 |
207 | def default_config_value(key) when key in [:actions, :tasks, :components, :hidden_fields],
208 | do: []
209 |
210 | def default_config_value(:label_with), do: :id
211 |
212 | def default_config_value(_), do: nil
213 |
214 | defp build_list(resource, opts, repo) do
215 | opts =
216 | opts
217 | |> Enum.into(%{})
218 | |> Map.put_new(:page, 1)
219 | |> Map.put_new(:sort_dir, :asc)
220 | |> Map.put_new(:sort_attr, :id)
221 |
222 | query =
223 | :schema
224 | |> resource.__live_admin_config__()
225 | |> limit(10)
226 | |> offset(^((opts[:page] - 1) * 10))
227 | |> order_by(^[{opts[:sort_dir], opts[:sort_attr]}])
228 | |> preload(^preloads(resource))
229 |
230 | query =
231 | opts
232 | |> Enum.reduce(query, fn
233 | {:search, q}, query when byte_size(q) > 0 ->
234 | apply_search(query, q, fields(resource))
235 |
236 | _, query ->
237 | query
238 | end)
239 |
240 | {
241 | repo.all(query, prefix: opts[:prefix]),
242 | repo.aggregate(
243 | query |> exclude(:limit) |> exclude(:offset),
244 | :count,
245 | prefix: opts[:prefix]
246 | )
247 | }
248 | end
249 |
250 | defp apply_search(query, q, fields) do
251 | q
252 | |> String.split(~r{[^\s]*:}, include_captures: true, trim: true)
253 | |> case do
254 | [q] ->
255 | matcher = if String.contains?(q, "%"), do: q, else: "%#{q}%"
256 |
257 | Enum.reduce(fields, query, fn {field_name, _, _}, query ->
258 | or_where(
259 | query,
260 | [r],
261 | like(
262 | fragment("LOWER(CAST(? AS text))", field(r, ^field_name)),
263 | ^String.downcase(matcher)
264 | )
265 | )
266 | end)
267 |
268 | field_queries ->
269 | field_queries
270 | |> Enum.map(&String.trim/1)
271 | |> Enum.chunk_every(2)
272 | |> Enum.reduce(query, fn
273 | [field_key, q], query ->
274 | fields
275 | |> Enum.find_value(fn {field_name, _, _} ->
276 | if "#{field_name}:" == field_key, do: field_name
277 | end)
278 | |> case do
279 | nil ->
280 | query
281 |
282 | field_name ->
283 | or_where(
284 | query,
285 | [r],
286 | ilike(fragment("CAST(? AS text)", field(r, ^field_name)), ^"%#{q}%")
287 | )
288 | end
289 |
290 | _, query ->
291 | query
292 | end)
293 | end
294 | end
295 |
296 | defp build_changeset(record = %schema{}, resource, params) do
297 | resource
298 | |> case do
299 | :embed ->
300 | Enum.map(schema.__schema__(:fields), fn field_name ->
301 | {field_name, schema.__schema__(:type, field_name), []}
302 | end)
303 |
304 | resource ->
305 | fields(resource)
306 | end
307 | |> Enum.reduce(Changeset.cast(record, params, []), fn
308 | {field_name, {_, Ecto.Embedded, %{cardinality: :many}}, _}, changeset ->
309 | Changeset.cast_embed(changeset, field_name,
310 | with: fn embed, params -> build_changeset(embed, :embed, params) end,
311 | sort_param: LiveAdmin.View.sort_param_name(field_name),
312 | drop_param: LiveAdmin.View.drop_param_name(field_name)
313 | )
314 |
315 | {field_name, {_, Ecto.Embedded, %{cardinality: :one}}, _}, changeset ->
316 | if Map.get(params, to_string(field_name)) == "" do
317 | Changeset.put_change(changeset, field_name, nil)
318 | else
319 | Changeset.cast_embed(changeset, field_name,
320 | with: fn embed, params -> build_changeset(embed, :embed, params) end
321 | )
322 | end
323 |
324 | {field_name, type, opts}, changeset ->
325 | unless Keyword.get(opts, :immutable, false) do
326 | changeset = Changeset.cast(changeset, params, [field_name])
327 |
328 | if type == :map do
329 | Changeset.update_change(changeset, field_name, &parse_map_param/1)
330 | else
331 | changeset
332 | end
333 | else
334 | changeset
335 | end
336 | end)
337 | end
338 |
339 | defp parse_map_param(param = %{}) do
340 | param
341 | |> Enum.sort_by(fn {idx, _} -> idx end)
342 | |> Map.new(fn {_, %{"key" => key, "value" => value}} -> {key, value} end)
343 | end
344 |
345 | defp parse_map_param(param), do: param
346 |
347 | defp preloads(resource) do
348 | :preload
349 | |> resource.__live_admin_config__()
350 | |> case do
351 | nil ->
352 | resource.__live_admin_config__(:schema)
353 | |> parent_associations()
354 | |> Enum.map(& &1.field)
355 |
356 | {m, f, a} ->
357 | apply(m, f, [resource | a])
358 |
359 | preloads when is_list(preloads) ->
360 | preloads
361 | end
362 | end
363 |
364 | defp get_assoc_name!(schema, fk) do
365 | Enum.find(schema.__schema__(:associations), fn assoc_name ->
366 | fk == schema.__schema__(:association, assoc_name).owner_key
367 | end)
368 | end
369 |
370 | defp render_field(val = %{}), do: Phoenix.HTML.Tag.content_tag(:pre, inspect(val, pretty: true))
371 | defp render_field(val) when is_list(val), do: Enum.map(val, &render_field/1)
372 | defp render_field(val) when is_binary(val), do: Phoenix.HTML.Format.text_to_html(val)
373 | defp render_field(val), do: val
374 | end
375 |
--------------------------------------------------------------------------------
/mix.lock:
--------------------------------------------------------------------------------
1 | %{
2 | "castore": {:hex, :castore, "1.0.3", "7130ba6d24c8424014194676d608cb989f62ef8039efd50ff4b3f33286d06db8", [:mix], [], "hexpm", "680ab01ef5d15b161ed6a95449fac5c6b8f60055677a8e79acf01b27baa4390b"},
3 | "connection": {:hex, :connection, "1.1.0", "ff2a49c4b75b6fb3e674bfc5536451607270aac754ffd1bdfe175abe4a6d7a68", [:mix], [], "hexpm", "722c1eb0a418fbe91ba7bd59a47e28008a189d47e37e0e7bb85585a016b2869c"},
4 | "cowboy": {:hex, :cowboy, "2.10.0", "ff9ffeff91dae4ae270dd975642997afe2a1179d94b1887863e43f681a203e26", [:make, :rebar3], [{:cowlib, "2.12.1", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "1.8.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "3afdccb7183cc6f143cb14d3cf51fa00e53db9ec80cdcd525482f5e99bc41d6b"},
5 | "cowboy_telemetry": {:hex, :cowboy_telemetry, "0.4.0", "f239f68b588efa7707abce16a84d0d2acf3a0f50571f8bb7f56a15865aae820c", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7d98bac1ee4565d31b62d59f8823dfd8356a169e7fcbb83831b8a5397404c9de"},
6 | "cowlib": {:hex, :cowlib, "2.12.1", "a9fa9a625f1d2025fe6b462cb865881329b5caff8f1854d1cbc9f9533f00e1e1", [:make, :rebar3], [], "hexpm", "163b73f6367a7341b33c794c4e88e7dbfe6498ac42dcd69ef44c5bc5507c8db0"},
7 | "db_connection": {:hex, :db_connection, "2.5.0", "bb6d4f30d35ded97b29fe80d8bd6f928a1912ca1ff110831edcd238a1973652c", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c92d5ba26cd69ead1ff7582dbb860adeedfff39774105a4f1c92cbb654b55aa2"},
8 | "decimal": {:hex, :decimal, "2.1.1", "5611dca5d4b2c3dd497dec8f68751f1f1a54755e8ed2a966c2633cf885973ad6", [:mix], [], "hexpm", "53cfe5f497ed0e7771ae1a475575603d77425099ba5faef9394932b35020ffcc"},
9 | "dialyxir": {:hex, :dialyxir, "1.2.0", "58344b3e87c2e7095304c81a9ae65cb68b613e28340690dfe1a5597fd08dec37", [:mix], [{:erlex, ">= 0.2.6", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "61072136427a851674cab81762be4dbeae7679f85b1272b6d25c3a839aff8463"},
10 | "docout": {:git, "https://github.com/tfwright/docout.git", "5a0ebd0a1cbb77bc9d82b6efd2d0d97d24ebb960", [branch: "main"]},
11 | "earmark_parser": {:hex, :earmark_parser, "1.4.20", "89970db71b11b6b89759ce16807e857df154f8df3e807b2920a8c39834a9e5cf", [:mix], [], "hexpm", "1eb0d2dabeeeff200e0d17dc3048a6045aab271f73ebb82e416464832eb57bdd"},
12 | "ecto": {:hex, :ecto, "3.10.3", "eb2ae2eecd210b4eb8bece1217b297ad4ff824b4384c0e3fdd28aaf96edd6135", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "44bec74e2364d491d70f7e42cd0d690922659d329f6465e89feb8a34e8cd3433"},
13 | "ecto_psql_extras": {:hex, :ecto_psql_extras, "0.7.4", "5d43fd088d39a158c860b17e8d210669587f63ec89ea122a4654861c8c6e2db4", [:mix], [{:ecto_sql, "~> 3.4", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:postgrex, ">= 0.15.7", [hex: :postgrex, repo: "hexpm", optional: false]}, {:table_rex, "~> 3.1.1", [hex: :table_rex, repo: "hexpm", optional: false]}], "hexpm", "311db02f1b772e3d0dc7f56a05044b5e1499d78ed6abf38885e1ca70059449e5"},
14 | "ecto_sql": {:hex, :ecto_sql, "3.10.2", "6b98b46534b5c2f8b8b5f03f126e75e2a73c64f3c071149d32987a5378b0fdbd", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.10.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16.0 or ~> 0.17.0 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "68c018debca57cb9235e3889affdaec7a10616a4e3a80c99fa1d01fdafaa9007"},
15 | "erlex": {:hex, :erlex, "0.2.6", "c7987d15e899c7a2f34f5420d2a2ea0d659682c06ac607572df55a43753aa12e", [:mix], [], "hexpm", "2ed2e25711feb44d52b17d2780eabf998452f6efda104877a3881c2f8c0c0c75"},
16 | "ex_doc": {:hex, :ex_doc, "0.28.2", "e031c7d1a9fc40959da7bf89e2dc269ddc5de631f9bd0e326cbddf7d8085a9da", [:mix], [{:earmark_parser, "~> 1.4.19", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "51ee866993ffbd0e41c084a7677c570d0fc50cb85c6b5e76f8d936d9587fa719"},
17 | "expo": {:hex, :expo, "0.4.1", "1c61d18a5df197dfda38861673d392e642649a9cef7694d2f97a587b2cfb319b", [:mix], [], "hexpm", "2ff7ba7a798c8c543c12550fa0e2cbc81b95d4974c65855d8d15ba7b37a1ce47"},
18 | "faker": {:hex, :faker, "0.17.0", "671019d0652f63aefd8723b72167ecdb284baf7d47ad3a82a15e9b8a6df5d1fa", [:mix], [], "hexpm", "a7d4ad84a93fd25c5f5303510753789fc2433ff241bf3b4144d3f6f291658a6a"},
19 | "file_system": {:hex, :file_system, "0.2.10", "fb082005a9cd1711c05b5248710f8826b02d7d1784e7c3451f9c1231d4fc162d", [:mix], [], "hexpm", "41195edbfb562a593726eda3b3e8b103a309b733ad25f3d642ba49696bf715dc"},
20 | "floki": {:hex, :floki, "0.32.0", "f915dc15258bc997d49be1f5ef7d3992f8834d6f5695270acad17b41f5bcc8e2", [:mix], [{:html_entities, "~> 0.5.0", [hex: :html_entities, repo: "hexpm", optional: false]}], "hexpm", "1c5a91cae1fd8931c26a4826b5e2372c284813904c8bacb468b5de39c7ececbd"},
21 | "gettext": {:hex, :gettext, "0.22.3", "c8273e78db4a0bb6fba7e9f0fd881112f349a3117f7f7c598fa18c66c888e524", [:mix], [{:expo, "~> 0.4.0", [hex: :expo, repo: "hexpm", optional: false]}], "hexpm", "935f23447713954a6866f1bb28c3a878c4c011e802bcd68a726f5e558e4b64bd"},
22 | "html_entities": {:hex, :html_entities, "0.5.2", "9e47e70598da7de2a9ff6af8758399251db6dbb7eebe2b013f2bbd2515895c3c", [:mix], [], "hexpm", "c53ba390403485615623b9531e97696f076ed415e8d8058b1dbaa28181f4fdcc"},
23 | "jason": {:hex, :jason, "1.4.1", "af1504e35f629ddcdd6addb3513c3853991f694921b1b9368b0bd32beb9f1b63", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "fbb01ecdfd565b56261302f7e1fcc27c4fb8f32d56eab74db621fc154604a7a1"},
24 | "makeup": {:hex, :makeup, "1.1.0", "6b67c8bc2882a6b6a445859952a602afc1a41c2e08379ca057c0f525366fc3ca", [:mix], [{:nimble_parsec, "~> 1.2.2 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "0a45ed501f4a8897f580eabf99a2e5234ea3e75a4373c8a52824f6e873be57a6"},
25 | "makeup_elixir": {:hex, :makeup_elixir, "0.16.0", "f8c570a0d33f8039513fbccaf7108c5d750f47d8defd44088371191b76492b0b", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "28b2cbdc13960a46ae9a8858c4bebdec3c9a6d7b4b9e7f4ed1502f8159f338e7"},
26 | "makeup_erlang": {:hex, :makeup_erlang, "0.1.1", "3fcb7f09eb9d98dc4d208f49cc955a34218fc41ff6b84df7c75b3e6e533cc65f", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "174d0809e98a4ef0b3309256cbf97101c6ec01c4ab0b23e926a9e17df2077cbb"},
27 | "mime": {:hex, :mime, "2.0.5", "dc34c8efd439abe6ae0343edbb8556f4d63f178594894720607772a041b04b02", [:mix], [], "hexpm", "da0d64a365c45bc9935cc5c8a7fc5e49a0e0f9932a761c55d6c52b142780a05c"},
28 | "mox": {:hex, :mox, "1.0.2", "dc2057289ac478b35760ba74165b4b3f402f68803dd5aecd3bfd19c183815d64", [:mix], [], "hexpm", "f9864921b3aaf763c8741b5b8e6f908f44566f1e427b2630e89e9a73b981fef2"},
29 | "nimble_parsec": {:hex, :nimble_parsec, "1.2.3", "244836e6e3f1200c7f30cb56733fd808744eca61fd182f731eac4af635cc6d0b", [:mix], [], "hexpm", "c8d789e39b9131acf7b99291e93dae60ab48ef14a7ee9d58c6964f59efb570b0"},
30 | "phoenix": {:hex, :phoenix, "1.7.7", "4cc501d4d823015007ba3cdd9c41ecaaf2ffb619d6fb283199fa8ddba89191e0", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "8966e15c395e5e37591b6ed0bd2ae7f48e961f0f60ac4c733f9566b519453085"},
31 | "phoenix_ecto": {:hex, :phoenix_ecto, "4.4.2", "b21bd01fdeffcfe2fab49e4942aa938b6d3e89e93a480d4aee58085560a0bc0d", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "70242edd4601d50b69273b057ecf7b684644c19ee750989fd555625ae4ce8f5d"},
32 | "phoenix_html": {:hex, :phoenix_html, "3.3.2", "d6ce982c6d8247d2fc0defe625255c721fb8d5f1942c5ac051f6177bffa5973f", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "44adaf8e667c1c20fb9d284b6b0fa8dc7946ce29e81ce621860aa7e96de9a11d"},
33 | "phoenix_live_reload": {:hex, :phoenix_live_reload, "1.3.3", "3a53772a6118d5679bf50fc1670505a290e32a1d195df9e069d8c53ab040c054", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "766796676e5f558dbae5d1bdb066849673e956005e3730dfd5affd7a6da4abac"},
34 | "phoenix_live_view": {:hex, :phoenix_live_view, "0.20.0", "3f3531c835e46a3b45b4c3ca4a09cef7ba1d0f0d0035eef751c7084b8adb1299", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "29875f8a58fb031f2dc8f3be025c92ed78d342b46f9bbf6dfe579549d7c81050"},
35 | "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.1.3", "3168d78ba41835aecad272d5e8cd51aa87a7ac9eb836eabc42f6e57538e3731d", [:mix], [], "hexpm", "bba06bc1dcfd8cb086759f0edc94a8ba2bc8896d5331a1e2c2902bf8e36ee502"},
36 | "phoenix_template": {:hex, :phoenix_template, "1.0.3", "32de561eefcefa951aead30a1f94f1b5f0379bc9e340bb5c667f65f1edfa4326", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "16f4b6588a4152f3cc057b9d0c0ba7e82ee23afa65543da535313ad8d25d8e2c"},
37 | "phoenix_view": {:hex, :phoenix_view, "2.0.2", "6bd4d2fd595ef80d33b439ede6a19326b78f0f1d8d62b9a318e3d9c1af351098", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "a929e7230ea5c7ee0e149ffcf44ce7cf7f4b6d2bfe1752dd7c084cdff152d36f"},
38 | "plug": {:hex, :plug, "1.14.2", "cff7d4ec45b4ae176a227acd94a7ab536d9b37b942c8e8fa6dfc0fff98ff4d80", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "842fc50187e13cf4ac3b253d47d9474ed6c296a8732752835ce4a86acdf68d13"},
39 | "plug_cowboy": {:hex, :plug_cowboy, "2.6.1", "9a3bbfceeb65eff5f39dab529e5cd79137ac36e913c02067dba3963a26efe9b2", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "de36e1a21f451a18b790f37765db198075c25875c64834bcc82d90b309eb6613"},
40 | "plug_crypto": {:hex, :plug_crypto, "1.2.5", "918772575e48e81e455818229bf719d4ab4181fcbf7f85b68a35620f78d89ced", [:mix], [], "hexpm", "26549a1d6345e2172eb1c233866756ae44a9609bd33ee6f99147ab3fd87fd842"},
41 | "postgrex": {:hex, :postgrex, "0.17.3", "c92cda8de2033a7585dae8c61b1d420a1a1322421df84da9a82a6764580c503d", [:mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "946cf46935a4fdca7a81448be76ba3503cff082df42c6ec1ff16a4bdfbfb098d"},
42 | "ranch": {:hex, :ranch, "1.8.0", "8c7a100a139fd57f17327b6413e4167ac559fbc04ca7448e9be9057311597a1d", [:make, :rebar3], [], "hexpm", "49fbcfd3682fab1f5d109351b61257676da1a2fdbe295904176d5e521a2ddfe5"},
43 | "table_rex": {:hex, :table_rex, "3.1.1", "0c67164d1714b5e806d5067c1e96ff098ba7ae79413cc075973e17c38a587caa", [:mix], [], "hexpm", "678a23aba4d670419c23c17790f9dcd635a4a89022040df7d5d772cb21012490"},
44 | "telemetry": {:hex, :telemetry, "1.2.1", "68fdfe8d8f05a8428483a97d7aab2f268aaff24b49e0f599faa091f1d4e7f61c", [:rebar3], [], "hexpm", "dad9ce9d8effc621708f99eac538ef1cbe05d6a874dd741de2e689c47feafed5"},
45 | "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
46 | "websock_adapter": {:hex, :websock_adapter, "0.5.4", "7af8408e7ed9d56578539594d1ee7d8461e2dd5c3f57b0f2a5352d610ddde757", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "d2c238c79c52cbe223fcdae22ca0bb5007a735b9e933870e241fce66afb4f4ab"},
47 | }
48 |
--------------------------------------------------------------------------------
/lib/live_admin/components/resource/index.ex:
--------------------------------------------------------------------------------
1 | defmodule LiveAdmin.Components.Container.Index do
2 | use Phoenix.LiveComponent
3 | use Phoenix.HTML
4 |
5 | import LiveAdmin,
6 | only: [
7 | route_with_params: 1,
8 | route_with_params: 2,
9 | trans: 1,
10 | trans: 2
11 | ]
12 |
13 | import LiveAdmin.Components
14 |
15 | alias LiveAdmin.Resource
16 | alias Phoenix.LiveView.JS
17 |
18 | @impl true
19 | def update(assigns, socket) do
20 | socket =
21 | socket
22 | |> assign(assigns)
23 | |> assign(
24 | records:
25 | Resource.list(
26 | assigns.resource,
27 | Map.take(assigns, [:prefix, :sort_attr, :sort_dir, :page, :search]),
28 | assigns.session,
29 | assigns.repo
30 | )
31 | )
32 |
33 | {:ok, socket}
34 | end
35 |
36 | @impl true
37 | def render(assigns) do
38 | ~H"""
39 |
40 |
41 |
42 |
52 |
58 |
59 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
76 | <%= for {field, _, _} <- Resource.fields(@resource) do %>
77 |
98 | <% end %>
99 |
100 |
101 |
102 | <%= for record <- @records |> elem(0) do %>
103 |
104 |
105 |
106 |
113 |
114 | <%= for {field, type, _} <- Resource.fields(@resource) do %>
115 | <% assoc_resource =
116 | LiveAdmin.associated_resource(
117 | @resource.__live_admin_config__(:schema),
118 | field,
119 | @resources
120 | ) %>
121 |
122 |
123 | <%= Resource.render(record, field, @resource, assoc_resource, @session) %>
124 |
125 |
126 |
135 | <%= if record |> Ecto.primary_key() |> Keyword.keys() |> Enum.member?(field) || (assoc_resource && Map.fetch!(record, field)) do %>
136 |
149 |
157 |
163 |
164 | <% end %>
165 |
167 | <% end %>
168 |
169 | <% end %>
170 |
171 |
172 |
215 |
247 |
248 |
249 |
250 |
LiveAdmin Dev
134 | Users
135 | Posts
136 | """)
137 | end
138 |
139 | defp content(conn, content) do
140 | conn
141 | |> put_resp_header("content-type", "text/html")
142 | |> send_resp(200, "#{content}")
143 | end
144 | end
145 |
146 | defmodule Demo.Accounts.User.Settings.Config do
147 | use Ecto.Schema
148 |
149 | @primary_key false
150 | embedded_schema do
151 | field :key, :string
152 | field :val, :string
153 |
154 | field :good, :boolean
155 | field :legal, :boolean
156 | end
157 | end
158 |
159 | defmodule Demo.Accounts.User.Settings do
160 | use Ecto.Schema
161 |
162 | embedded_schema do
163 | field :some_option, :string
164 |
165 | embeds_many :configs, __MODULE__.Config, on_replace: :delete
166 | end
167 | end
168 |
169 | defmodule Demo.Accounts.User.Profile do
170 | use Ecto.Schema
171 | use LiveAdmin.Resource, create_with: false
172 |
173 | schema "user_profiles" do
174 | belongs_to :user, Demo.Accounts.User, type: :binary_id
175 | end
176 | end
177 |
178 | defmodule Demo.Accounts.User do
179 | use Ecto.Schema
180 |
181 | @primary_key {:id, :binary_id, autogenerate: true}
182 | schema "users" do
183 | field :name, :string
184 | field :email, :string
185 | field :active, :boolean
186 | field :birth_date, :date
187 | field :stars_count, :integer
188 | field :private_data, :map
189 | field :encrypted_password, :string
190 | field :status, Ecto.Enum, values: [:active, :suspended]
191 | field :roles, {:array, Ecto.Enum}, values: [:admin, :staff]
192 | field :rating, :float
193 |
194 | field :password, :string, virtual: true
195 |
196 | embeds_one :settings, Demo.Accounts.User.Settings, on_replace: :delete
197 |
198 | has_many :posts, Demo.Posts.Post
199 |
200 | timestamps(updated_at: false)
201 | end
202 | end
203 |
204 | defmodule Demo.Posts.Post.Version do
205 | use Ecto.Schema
206 |
207 | @primary_key false
208 | embedded_schema do
209 | field :body, :string
210 | field :tags, {:array, :string}
211 |
212 | timestamps(updated_at: false)
213 | end
214 | end
215 |
216 | defmodule Demo.Posts.Post do
217 | use Ecto.Schema
218 | use LiveAdmin.Resource,
219 | immutable_fields: [:disabled_user_id],
220 | tasks: [:fail],
221 | validate_with: :validate,
222 | update_with: :update,
223 | ecto_repo: Demo.Repo
224 |
225 | import Ecto.Changeset
226 |
227 | schema "posts" do
228 | field :title, :string
229 | field :body, :string
230 | field :tags, {:array, :string}, default: []
231 | field :categories, {:array, Ecto.Enum}, values: [:personal, :work]
232 | field :status, Ecto.Enum, values: [:draft, :archived, :live]
233 | field :metadata, :map
234 |
235 | embeds_many :previous_versions, __MODULE__.Version, on_replace: :delete
236 |
237 | belongs_to :user, Demo.Accounts.User, type: :binary_id
238 | belongs_to :disabled_user, Demo.Accounts.User, type: :binary_id
239 |
240 | timestamps(updated_at: false)
241 | end
242 |
243 | def fail(_) do
244 | {:error, "failed"}
245 | end
246 |
247 | def validate(changeset, _) do
248 | changeset
249 | |> Ecto.Changeset.validate_required([:title, :body, :user_id])
250 | |> Ecto.Changeset.validate_length(:title, max: 10, message: "cannot be longer than 10 characters")
251 | end
252 |
253 | def update(record, params, _) do
254 | record
255 | |> Ecto.Changeset.cast(params, [:title, :body, :user_id, :inserted_at, :tags, :categories])
256 | |> Ecto.Changeset.cast_embed(:previous_versions, with: fn version, params ->
257 | Ecto.Changeset.cast(version, params, [:body, :tags, :inserted_at])
258 | end)
259 | |> Ecto.Changeset.validate_required([:title, :body, :user_id, :inserted_at])
260 | |> Ecto.Changeset.validate_length(:title, max: 10, message: "cannot be longer than 10 characters")
261 | |> Ecto.Changeset.validate_change(:title, fn _, new_title ->
262 | if !String.contains?(new_title, record.title) do
263 | [title: "must contain original"]
264 | else
265 | []
266 | end
267 | end)
268 | |> Demo.Repo.update()
269 | end
270 | end
271 |
272 | defmodule Demo.Populator do
273 | import Ecto.Query
274 |
275 | alias Demo.Repo
276 |
277 | def reset do
278 | teardown()
279 | run()
280 | end
281 |
282 | def run do
283 | Enum.each(1..100, fn _ ->
284 | %Demo.Accounts.User{
285 | name: Faker.Person.name(),
286 | email: "#{Ecto.UUID.generate()}@example.com",
287 | settings: %{},
288 | active: true,
289 | birth_date: ~D[1999-12-31],
290 | stars_count: Enum.random(0..100),
291 | private_data: %{},
292 | encrypted_password: :crypto.strong_rand_bytes(16) |> Base.encode16(),
293 | posts: [
294 | %Demo.Posts.Post{
295 | title: Faker.Lorem.paragraph(1) |> String.slice(0..9),
296 | body: Faker.Lorem.paragraphs() |> Enum.join("\n\n"),
297 | disabled_user: get_user_if(:rand.uniform(2) == 1)
298 | }
299 | ]
300 | }
301 | |> Demo.Repo.insert!()
302 | end)
303 | end
304 |
305 | defp teardown do
306 | Repo.delete_all(Demo.Accounts.User)
307 | Repo.delete_all(Demo.Posts.Post)
308 | Repo.delete_all(Demo.Accounts.User.Profile)
309 | end
310 |
311 | defp get_user_if(true), do: from(Demo.Accounts.User, order_by: fragment("RANDOM()"), limit: 1) |> Demo.Repo.one()
312 | defp get_user_if(false), do: nil
313 | end
314 |
315 | defmodule DemoWeb.CreateUserForm do
316 | use Phoenix.LiveComponent
317 | use Phoenix.HTML
318 |
319 | import LiveAdmin, only: [route_with_params: 2]
320 | import LiveAdmin.ErrorHelpers
321 |
322 | @impl true
323 | def update(assigns, socket) do
324 | socket =
325 | socket
326 | |> assign(assigns)
327 | |> assign(:changeset, Ecto.Changeset.change(%Demo.Accounts.User{}))
328 |
329 | {:ok, socket}
330 | end
331 |
332 | @impl true
333 | def render(assigns) do
334 | assigns = assign(assigns, :enabled, Enum.empty?(assigns.changeset.errors))
335 |
336 | ~H"""
337 |
338 | <.form
339 | :let={f}
340 | for={@changeset}
341 | as={:params}
342 | phx-change="validate"
343 | phx-submit="create"
344 | phx-target={@myself}
345 | class="resource__form"
346 | >
347 |
348 |
349 | <%= label(f, :name, class: "field__label") %>
350 | <%= textarea(f, :name, rows: 1, class: "field__text") %>
351 | <%= error_tag(f, :name) %>
352 |
353 |
354 |
355 | <%= label(f, :email, class: "field__label") %>
356 | <%= textarea(f, :email, rows: 1, class: "field__text") %>
357 | <%= error_tag(f, :email) %>
358 |
359 |
360 |
361 | <%= label(f, :password, class: "field__label") %>
362 | <%= password_input(f, :password, class: "field__text", value: input_value(f, :password)) %>
363 | <%= error_tag(f, :password) %>
364 |
365 |
366 |
367 | <%= label(f, :password_confirmation, class: "field__label") %>
368 | <%= password_input(f, :password_confirmation, class: "field__text") %>
369 | <%= error_tag(f, :password_confirmation) %>
370 |
371 |
372 |
373 | <%= submit("Save",
374 | class: "resource__action#{if !@enabled, do: "--disabled", else: "--btn"}",
375 | disabled: !@enabled
376 | ) %>
377 |
378 |
379 |
465 |
466 | This is only for managing posts
467 |
468 |