feat: migration to phoenix 1.8 - merge old live views into new live views

lib/mv_web/live/member_live/form.ex

@@ -7,39 +7,47 @@ defmodule MvWeb.MemberLive.Form do
     <Layouts.app flash={@flash}>
       <.header>
         {@page_title}
-        <:subtitle>Use this form to manage member records in your database.</:subtitle>
+        <:subtitle>
+          {gettext("Use this form to manage member records and their properties.")}
+        </:subtitle>
       </.header>
 
       <.form for={@form} id="member-form" phx-change="validate" phx-submit="save">
-        <.input field={@form[:properties]} type="select" multiple label="Properties" options={[]} />
-        <.input field={@form[:first_name]} type="text" label="First name" /><.input
-          field={@form[:last_name]}
-          type="text"
-          label="Last name"
-        /><.input field={@form[:email]} type="text" label="Email" /><.input
-          field={@form[:birth_date]}
-          type="date"
-          label="Birth date"
-        /><.input field={@form[:paid]} type="checkbox" label="Paid" /><.input
-          field={@form[:phone_number]}
-          type="text"
-          label="Phone number"
-        /><.input field={@form[:join_date]} type="date" label="Join date" /><.input
-          field={@form[:exit_date]}
-          type="date"
-          label="Exit date"
-        /><.input field={@form[:notes]} type="text" label="Notes" /><.input
-          field={@form[:city]}
-          type="text"
-          label="City"
-        /><.input field={@form[:street]} type="text" label="Street" /><.input
-          field={@form[:house_number]}
-          type="text"
-          label="House number"
-        /><.input field={@form[:postal_code]} type="text" label="Postal code" />
+        <.input field={@form[:first_name]} label={gettext("First Name")} required />
+        <.input field={@form[:last_name]} label={gettext("Last Name")} required />
+        <.input field={@form[:email]} label={gettext("Email")} required type="email" />
+        <.input field={@form[:birth_date]} label={gettext("Birth Date")} type="date" />
+        <.input field={@form[:paid]} label={gettext("Paid")} type="checkbox" />
+        <.input field={@form[:phone_number]} label={gettext("Phone Number")} />
+        <.input field={@form[:join_date]} label={gettext("Join Date")} type="date" />
+        <.input field={@form[:exit_date]} label={gettext("Exit Date")} type="date" />
+        <.input field={@form[:notes]} label={gettext("Notes")} />
+        <.input field={@form[:city]} label={gettext("City")} />
+        <.input field={@form[:street]} label={gettext("Street")} />
+        <.input field={@form[:house_number]} label={gettext("House Number")} />
+        <.input field={@form[:postal_code]} label={gettext("Postal Code")} />
 
-        <.button phx-disable-with="Saving..." variant="primary">Save Member</.button>
-        <.button navigate={return_path(@return_to, @member)}>Cancel</.button>
+        <h3 class="mt-8 mb-2 text-lg font-semibold">{gettext("Custom Properties")}</h3>
+        <.inputs_for :let={f_property} field={@form[:properties]}>
+          <% type = Enum.find(@property_types, &(&1.id == f_property[:property_type_id].value)) %>
+          <.inputs_for :let={value_form} field={f_property[:value]}>
+            <% input_type =
+              cond do
+                type && type.value_type == :boolean -> "checkbox"
+                type && type.value_type == :date -> :date
+                true -> :text
+              end %>
+            <.input field={value_form[:value]} label={type && type.name} type={input_type} />
+          </.inputs_for>
+          <input
+            type="hidden"
+            name={f_property[:property_type_id].name}
+            value={f_property[:property_type_id].value}
+          />
+        </.inputs_for>
+
+        <.button phx-disable-with={gettext("Saving...")} variant="primary">{gettext("Save Member")}</.button>
+        <.button navigate={return_path(@return_to, @member)}>{gettext("Cancel")}</.button>
       </.form>
     </Layouts.app>
     """
@@ -47,6 +55,20 @@ defmodule MvWeb.MemberLive.Form do
 
   @impl true
   def mount(params, _session, socket) do
+    {:ok, property_types} = Mv.Membership.list_property_types()
+
+    initial_properties =
+      Enum.map(property_types, fn pt ->
+        %{
+          "property_type_id" => pt.id,
+          "value" => %{
+            "type" => pt.value_type,
+            "value" => nil,
+            "_union_type" => Atom.to_string(pt.value_type)
+          }
+        }
+      end)
+
     member =
       case params["id"] do
         nil -> nil
@@ -59,6 +81,8 @@ defmodule MvWeb.MemberLive.Form do
     {:ok,
      socket
      |> assign(:return_to, return_to(params["return_to"]))
+     |> assign(:property_types, property_types)
+     |> assign(:initial_properties, initial_properties)
      |> assign(member: member)
      |> assign(:page_title, page_title)
      |> assign_form()}
@@ -77,9 +101,16 @@ defmodule MvWeb.MemberLive.Form do
       {:ok, member} ->
         notify_parent({:saved, member})
 
+        action =
+          case socket.assigns.form.source.type do
+            :create -> gettext("create")
+            :update -> gettext("update")
+            other -> to_string(other)
+          end
+
         socket =
           socket
-          |> put_flash(:info, "Member #{socket.assigns.form.source.type}d successfully")
+          |> put_flash(:info, gettext("Member %{action} successfully", action: action))
           |> push_navigate(to: return_path(socket.assigns.return_to, member))
 
         {:noreply, socket}
@@ -94,9 +125,56 @@ defmodule MvWeb.MemberLive.Form do
   defp assign_form(%{assigns: %{member: member}} = socket) do
     form =
       if member do
-        AshPhoenix.Form.for_update(member, :update_member, as: "member")
+        {:ok, member} = Ash.load(member, properties: [:property_type])
+
+        existing_properties =
+          member.properties
+          |> Enum.map(& &1.property_type_id)
+
+        is_missing_property = fn i ->
+          not Enum.member?(existing_properties, Map.get(i, "property_type_id"))
+        end
+
+        params = %{
+          "properties" =>
+            Enum.map(member.properties, fn prop ->
+              %{
+                "property_type_id" => prop.property_type_id,
+                "value" => %{
+                  "_union_type" => Atom.to_string(prop.value.type),
+                  "type" => prop.value.type,
+                  "value" => prop.value.value
+                }
+              }
+            end)
+        }
+
+        form =
+          AshPhoenix.Form.for_update(
+            member,
+            :update_member,
+            api: Mv.Membership,
+            as: "member",
+            params: params,
+            forms: [auto?: true]
+          )
+
+        missing_properties = Enum.filter(socket.assigns[:initial_properties], is_missing_property)
+
+        Enum.reduce(
+          missing_properties,
+          form,
+          &AshPhoenix.Form.add_form(&2, [:properties], params: &1)
+        )
       else
-        AshPhoenix.Form.for_create(Mv.Membership.Member, :create_member, as: "member")
+        AshPhoenix.Form.for_create(
+          Mv.Membership.Member,
+          :create_member,
+          api: Mv.Membership,
+          as: "member",
+          params: %{"properties" => socket.assigns[:initial_properties]},
+          forms: [auto?: true]
+        )
       end
 
     assign(socket, form: to_form(form))

lib/mv_web/live/member_live/index.ex

@@ -6,10 +6,10 @@ defmodule MvWeb.MemberLive.Index do
     ~H"""
     <Layouts.app flash={@flash}>
       <.header>
-        Listing Members
+        {gettext("Listing Members")}
         <:actions>
           <.button variant="primary" navigate={~p"/members/new"}>
-            <.icon name="hero-plus" /> New Member
+            <.icon name="hero-plus" /> {gettext("New Member")}
           </.button>
         </:actions>
       </.header>
@@ -19,22 +19,27 @@ defmodule MvWeb.MemberLive.Index do
         rows={@streams.members}
         row_click={fn {_id, member} -> JS.navigate(~p"/members/#{member}") end}
       >
-        <:col :let={{_id, member}} label="Id">{member.id}</:col>
+        <!-- <:col :let={{_id, member}} label="Id">{member.id}</:col> -->
+        <:col :let={{_id, member}} label={gettext("First Name")}>{member.first_name}</:col>
+        <:col :let={{_id, member}} label={gettext("Last Name")}>{member.last_name}</:col>
+        <:col :let={{_id, member}} label={gettext("Email")}>{member.email}</:col>
+        <:col :let={{_id, member}} label={gettext("City")}>{member.city}</:col>
+        <:col :let={{_id, member}} label={gettext("Join Date")}>{member.join_date}</:col>
 
         <:action :let={{_id, member}}>
           <div class="sr-only">
-            <.link navigate={~p"/members/#{member}"}>Show</.link>
+            <.link navigate={~p"/members/#{member}"}>{gettext("Show")}</.link>
           </div>
 
-          <.link navigate={~p"/members/#{member}/edit"}>Edit</.link>
+          <.link navigate={~p"/members/#{member}/edit"}>{gettext("Edit")}</.link>
         </:action>
 
         <:action :let={{id, member}}>
           <.link
             phx-click={JS.push("delete", value: %{id: member.id}) |> hide("##{id}")}
-            data-confirm="Are you sure?"
+            data-confirm={gettext("Are you sure?")}
           >
-            Delete
+            {gettext("Delete")}
           </.link>
         </:action>
       </.table>
@@ -46,7 +51,7 @@ defmodule MvWeb.MemberLive.Index do
   def mount(_params, _session, socket) do
     {:ok,
      socket
-     |> assign(:page_title, "Listing Members")
+     |> assign(:page_title, gettext("Listing Members"))
      |> stream(:members, Ash.read!(Mv.Membership.Member))}
   end
 

lib/mv_web/live/member_live/show.ex

@@ -1,36 +1,82 @@
 defmodule MvWeb.MemberLive.Show do
   use MvWeb, :live_view
+  import Ash.Query
 
   @impl true
   def render(assigns) do
     ~H"""
     <Layouts.app flash={@flash}>
       <.header>
-        Member {@member.id}
-        <:subtitle>This is a member record from your database.</:subtitle>
+        {@member.first_name} {@member.last_name}
+        <:subtitle>{gettext("This is a member record from your database.")}</:subtitle>
 
         <:actions>
           <.button navigate={~p"/members"}>
             <.icon name="hero-arrow-left" />
           </.button>
           <.button variant="primary" navigate={~p"/members/#{@member}/edit?return_to=show"}>
-            <.icon name="hero-pencil-square" /> Edit Member
+            <.icon name="hero-pencil-square" /> {gettext("Edit Member")}
           </.button>
         </:actions>
       </.header>
 
       <.list>
-        <:item title="Id">{@member.id}</:item>
+        <:item title={gettext("Id")}>{@member.id}</:item>
+        <:item title={gettext("First Name")}>{@member.first_name}</:item>
+        <:item title={gettext("Last Name")}>{@member.last_name}</:item>
+        <:item title={gettext("Email")}>{@member.email}</:item>
+        <:item title={gettext("Birth Date")}>{@member.birth_date}</:item>
+        <:item title={gettext("Paid")}>
+          {if @member.paid, do: gettext("Yes"), else: gettext("No")}
+        </:item>
+        <:item title={gettext("Phone Number")}>{@member.phone_number}</:item>
+        <:item title={gettext("Join Date")}>{@member.join_date}</:item>
+        <:item title={gettext("Exit Date")}>{@member.exit_date}</:item>
+        <:item title={gettext("Notes")}>{@member.notes}</:item>
+        <:item title={gettext("City")}>{@member.city}</:item>
+        <:item title={gettext("Street")}>{@member.street}</:item>
+        <:item title={gettext("House Number")}>{@member.house_number}</:item>
+        <:item title={gettext("Postal Code")}>{@member.postal_code}</:item>
       </.list>
+
+      <h3 class="mt-8 mb-2 text-lg font-semibold">{gettext("Custom Properties")}</h3>
+      <.generic_list items={
+        Enum.map(@member.properties, fn p ->
+          {
+            # name
+            p.property_type && p.property_type.name,
+            # value
+            case p.value do
+              %{value: v} -> v
+              v -> v
+            end
+          }
+        end)
+      } />
     </Layouts.app>
     """
   end
 
   @impl true
-  def mount(%{"id" => id}, _session, socket) do
-    {:ok,
-     socket
-     |> assign(:page_title, "Show Member")
-     |> assign(:member, Ash.get!(Mv.Membership.Member, id))}
+  def mount(_params, _session, socket) do
+    {:ok, socket}
   end
+
+  @impl true
+  def handle_params(%{"id" => id}, _, socket) do
+    query =
+      Mv.Membership.Member
+      |> filter(id == ^id)
+      |> load(properties: [:property_type])
+
+    member = Ash.read_one!(query)
+
+    {:noreply,
+     socket
+     |> assign(:page_title, page_title(socket.assigns.live_action))
+     |> assign(:member, member)}
+  end
+
+  defp page_title(:show), do: gettext("Show Member")
+  defp page_title(:edit), do: gettext("Edit Member")
 end

lib/mv_web/live/property_live/form.ex

@@ -7,18 +7,16 @@ defmodule MvWeb.PropertyLive.Form do
     <Layouts.app flash={@flash}>
       <.header>
         {@page_title}
-        <:subtitle>Use this form to manage property records in your database.</:subtitle>
+        <:subtitle>{gettext("Use this form to manage property records in your database.")}</:subtitle>
       </.header>
 
       <.form for={@form} id="property-form" phx-change="validate" phx-submit="save">
-        <.input field={@form[:value]} type="text" label="Value" /><.input
-          field={@form[:member_id]}
-          type="text"
-          label="Member"
-        /><.input field={@form[:property_type_id]} type="text" label="Property type" />
+        <.input field={@form[:value]} type="text" label={gettext("Value")} />
+        <.input field={@form[:member_id]} type="text" label={gettext("Member")} />
+        <.input field={@form[:property_type_id]} type="text" label={gettext("Property type")} />
 
-        <.button phx-disable-with="Saving..." variant="primary">Save Property</.button>
-        <.button navigate={return_path(@return_to, @property)}>Cancel</.button>
+        <.button phx-disable-with={gettext("Saving...")} variant="primary">{gettext("Save Property")}</.button>
+        <.button navigate={return_path(@return_to, @property)}>{gettext("Cancel")}</.button>
       </.form>
     </Layouts.app>
     """
@@ -57,9 +55,16 @@ defmodule MvWeb.PropertyLive.Form do
       {:ok, property} ->
         notify_parent({:saved, property})
 
+        action =
+          case socket.assigns.form.source.type do
+            :create -> gettext("create")
+            :update -> gettext("update")
+            other -> to_string(other)
+          end
+
         socket =
           socket
-          |> put_flash(:info, "Property #{socket.assigns.form.source.type}d successfully")
+          |> put_flash(:info, gettext("Property %{action} successfully", action: action))
           |> push_navigate(to: return_path(socket.assigns.return_to, property))
 
         {:noreply, socket}

lib/mv_web/live/property_live/show.ex

@@ -27,10 +27,18 @@ defmodule MvWeb.PropertyLive.Show do
   end
 
   @impl true
-  def mount(%{"id" => id}, _session, socket) do
-    {:ok,
+  def mount(_params, _session, socket) do
+    {:ok, socket}
+  end
+
+  @impl true
+  def handle_params(%{"id" => id}, _, socket) do
+    {:noreply,
      socket
-     |> assign(:page_title, "Show Property")
+     |> assign(:page_title, page_title(socket.assigns.live_action))
      |> assign(:property, Ash.get!(Mv.Membership.Property, id))}
   end
+
+  defp page_title(:show), do: "Show Property"
+  defp page_title(:edit), do: "Edit Property"
 end

lib/mv_web/live/property_type_live/form.ex

@@ -7,26 +7,25 @@ defmodule MvWeb.PropertyTypeLive.Form do
     <Layouts.app flash={@flash}>
       <.header>
         {@page_title}
-        <:subtitle>Use this form to manage property_type records in your database.</:subtitle>
+        <:subtitle>{gettext("Use this form to manage property_type records in your database.")}</:subtitle>
       </.header>
 
       <.form for={@form} id="property_type-form" phx-change="validate" phx-submit="save">
-        <.input field={@form[:name]} type="text" label="Name" /><.input
+        <.input field={@form[:name]} type="text" label={gettext("Name")} />
+        <.input
           field={@form[:value_type]}
           type="select"
-          label="Value type"
+          label={gettext("Value type")}
           options={
             Ash.Resource.Info.attribute(Mv.Membership.PropertyType, :value_type).constraints[:one_of]
           }
         />
-        <.input field={@form[:description]} type="text" label="Description" /><.input
-          field={@form[:immutable]}
-          type="checkbox"
-          label="Immutable"
-        /><.input field={@form[:required]} type="checkbox" label="Required" />
+        <.input field={@form[:description]} type="text" label={gettext("Description")} />
+        <.input field={@form[:immutable]} type="checkbox" label={gettext("Immutable")} />
+        <.input field={@form[:required]} type="checkbox" label={gettext("Required")} />
 
-        <.button phx-disable-with="Saving..." variant="primary">Save Property type</.button>
-        <.button navigate={return_path(@return_to, @property_type)}>Cancel</.button>
+        <.button phx-disable-with={gettext("Saving...")} variant="primary">{gettext("Save Property type")}</.button>
+        <.button navigate={return_path(@return_to, @property_type)}>{gettext("Cancel")}</.button>
       </.form>
     </Layouts.app>
     """
@@ -65,9 +64,16 @@ defmodule MvWeb.PropertyTypeLive.Form do
       {:ok, property_type} ->
         notify_parent({:saved, property_type})
 
+        action =
+          case socket.assigns.form.source.type do
+            :create -> gettext("create")
+            :update -> gettext("update")
+            other -> to_string(other)
+          end
+
         socket =
           socket
-          |> put_flash(:info, "Property type #{socket.assigns.form.source.type}d successfully")
+          |> put_flash(:info, gettext("Property type %{action} successfully", action: action))
           |> push_navigate(to: return_path(socket.assigns.return_to, property_type))
 
         {:noreply, socket}

lib/mv_web/member_live/form_component.ex

@@ -1,178 +0,0 @@
-defmodule MvWeb.MemberLive.FormComponent do
-  use MvWeb, :live_component
-
-  @impl true
-  def mount(socket) do
-    {:ok, property_types} = Mv.Membership.list_property_types()
-
-    initial_properties =
-      Enum.map(property_types, fn pt ->
-        %{
-          "property_type_id" => pt.id,
-          "value" => %{
-            "type" => pt.value_type,
-            "value" => nil,
-            "_union_type" => Atom.to_string(pt.value_type)
-          }
-        }
-      end)
-
-    {:ok, assign(socket, property_types: property_types, initial_properties: initial_properties)}
-  end
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <div>
-      <.header>
-        {@title}
-        <:subtitle>
-          {gettext("Use this form to manage member records and their properties.")}
-        </:subtitle>
-      </.header>
-
-      <.simple_form
-        for={@form}
-        id="member-form"
-        phx-target={@myself}
-        phx-change="validate"
-        phx-submit="save"
-      >
-        <.input field={@form[:first_name]} label={gettext("First Name")} required />
-        <.input field={@form[:last_name]} label={gettext("Last Name")} required />
-        <.input field={@form[:email]} label={gettext("Email")} required type="email" />
-        <.input field={@form[:birth_date]} label={gettext("Birth Date")} type="date" />
-        <.input field={@form[:paid]} label={gettext("Paid")} type="checkbox" />
-        <.input field={@form[:phone_number]} label={gettext("Phone Number")} />
-        <.input field={@form[:join_date]} label={gettext("Join Date")} type="date" />
-        <.input field={@form[:exit_date]} label={gettext("Exit Date")} type="date" />
-        <.input field={@form[:notes]} label={gettext("Notes")} />
-        <.input field={@form[:city]} label={gettext("City")} />
-        <.input field={@form[:street]} label={gettext("Street")} />
-        <.input field={@form[:house_number]} label={gettext("House Number")} />
-        <.input field={@form[:postal_code]} label={gettext("Postal Code")} />
-
-        <h3 class="mt-8 mb-2 text-lg font-semibold">{gettext("Custom Properties")}</h3>
-        <.inputs_for :let={f_property} field={@form[:properties]}>
-          <% type = Enum.find(@property_types, &(&1.id == f_property[:property_type_id].value)) %>
-          <.inputs_for :let={value_form} field={f_property[:value]}>
-            <% input_type =
-              cond do
-                type && type.value_type == :boolean -> "checkbox"
-                type && type.value_type == :date -> :date
-                true -> :text
-              end %>
-            <.input field={value_form[:value]} label={type && type.name} type={input_type} />
-          </.inputs_for>
-          <input
-            type="hidden"
-            name={f_property[:property_type_id].name}
-            value={f_property[:property_type_id].value}
-          />
-        </.inputs_for>
-
-        <:actions>
-          <.button phx-disable-with={gettext("Saving...")}>{gettext("Save Member")}</.button>
-        </:actions>
-      </.simple_form>
-    </div>
-    """
-  end
-
-  @impl true
-  def update(assigns, socket) do
-    {:ok,
-     socket
-     |> assign(assigns)
-     |> assign_form()}
-  end
-
-  @impl true
-  def handle_event("validate", %{"member" => member_params}, socket) do
-    {:noreply, assign(socket, form: AshPhoenix.Form.validate(socket.assigns.form, member_params))}
-  end
-
-  def handle_event("save", %{"member" => member_params}, socket) do
-    case AshPhoenix.Form.submit(socket.assigns.form, params: member_params) do
-      {:ok, member} ->
-        notify_parent({:saved, member})
-
-        action =
-          case socket.assigns.form.source.type do
-            :create -> gettext("create")
-            :update -> gettext("update")
-            other -> to_string(other)
-          end
-
-        socket =
-          socket
-          |> put_flash(:info, gettext("Member %{action} successfully", action: action))
-          |> push_patch(to: socket.assigns.patch)
-
-        {:noreply, socket}
-
-      {:error, form} ->
-        {:noreply, assign(socket, form: form)}
-    end
-  end
-
-  defp notify_parent(msg), do: send(self(), {__MODULE__, msg})
-
-  defp assign_form(%{assigns: %{member: member}} = socket) do
-    form =
-      if member do
-        {:ok, member} = Ash.load(member, properties: [:property_type])
-
-        existing_properties =
-          member.properties
-          |> Enum.map(& &1.property_type_id)
-
-        is_missing_property = fn i ->
-          not Enum.member?(existing_properties, Map.get(i, "property_type_id"))
-        end
-
-        params = %{
-          "properties" =>
-            Enum.map(member.properties, fn prop ->
-              %{
-                "property_type_id" => prop.property_type_id,
-                "value" => %{
-                  "_union_type" => Atom.to_string(prop.value.type),
-                  "type" => prop.value.type,
-                  "value" => prop.value.value
-                }
-              }
-            end)
-        }
-
-        form =
-          AshPhoenix.Form.for_update(
-            member,
-            :update_member,
-            api: Mv.Membership,
-            as: "member",
-            params: params,
-            forms: [auto?: true]
-          )
-
-        missing_properties = Enum.filter(socket.assigns[:initial_properties], is_missing_property)
-
-        Enum.reduce(
-          missing_properties,
-          form,
-          &AshPhoenix.Form.add_form(&2, [:properties], params: &1)
-        )
-      else
-        AshPhoenix.Form.for_create(
-          Mv.Membership.Member,
-          :create_member,
-          api: Mv.Membership,
-          as: "member",
-          params: %{"properties" => socket.assigns[:initial_properties]},
-          forms: [auto?: true]
-        )
-      end
-
-    assign(socket, form: to_form(form))
-  end
-end

lib/mv_web/member_live/index.ex

@@ -1,104 +0,0 @@
-defmodule MvWeb.MemberLive.Index do
-  use MvWeb, :live_view
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <.header>
-      {gettext("Listing Members")}
-      <:actions>
-        <.link patch={~p"/members/new"}>
-          <.button>{gettext("New Member")}</.button>
-        </.link>
-      </:actions>
-    </.header>
-
-    <.table
-      id="members"
-      rows={@streams.members}
-      row_click={fn {_id, member} -> JS.navigate(~p"/members/#{member}") end}
-    >
-      <!-- <:col :let={{_id, member}} label="Id">{member.id}</:col> -->
-      <:col :let={{_id, member}} label={gettext("First Name")}>{member.first_name}</:col>
-      <:col :let={{_id, member}} label={gettext("Last Name")}>{member.last_name}</:col>
-      <:col :let={{_id, member}} label={gettext("Email")}>{member.email}</:col>
-      <:col :let={{_id, member}} label={gettext("City")}>{member.city}</:col>
-      <:col :let={{_id, member}} label={gettext("Join Date")}>{member.join_date}</:col>
-
-      <:action :let={{_id, member}}>
-        <div class="sr-only">
-          <.link navigate={~p"/members/#{member}"}>{gettext("Show")}</.link>
-        </div>
-
-        <.link patch={~p"/members/#{member}/edit"}>{gettext("Edit")}</.link>
-      </:action>
-
-      <:action :let={{id, member}}>
-        <.link
-          phx-click={JS.push("delete", value: %{id: member.id}) |> hide("##{id}")}
-          data-confirm={gettext("Are you sure?")}
-        >
-          {gettext("Delete")}
-        </.link>
-      </:action>
-    </.table>
-
-    <.modal
-      :if={@live_action in [:new, :edit]}
-      id="member-modal"
-      show
-      on_cancel={JS.patch(~p"/members")}
-    >
-      <.live_component
-        module={MvWeb.MemberLive.FormComponent}
-        id={(@member && @member.id) || :new}
-        title={@page_title}
-        action={@live_action}
-        member={@member}
-        patch={~p"/members"}
-      />
-    </.modal>
-    """
-  end
-
-  @impl true
-  def mount(_params, _session, socket) do
-    {:ok, stream(socket, :members, Ash.read!(Mv.Membership.Member))}
-  end
-
-  @impl true
-  def handle_params(params, _url, socket) do
-    {:noreply, apply_action(socket, socket.assigns.live_action, params)}
-  end
-
-  defp apply_action(socket, :edit, %{"id" => id}) do
-    socket
-    |> assign(:page_title, gettext("Edit Member"))
-    |> assign(:member, Ash.get!(Mv.Membership.Member, id))
-  end
-
-  defp apply_action(socket, :new, _params) do
-    socket
-    |> assign(:page_title, gettext("New Member"))
-    |> assign(:member, nil)
-  end
-
-  defp apply_action(socket, :index, _params) do
-    socket
-    |> assign(:page_title, gettext("Listing Members"))
-    |> assign(:member, nil)
-  end
-
-  @impl true
-  def handle_info({MvWeb.MemberLive.FormComponent, {:saved, member}}, socket) do
-    {:noreply, stream_insert(socket, :members, member)}
-  end
-
-  @impl true
-  def handle_event("delete", %{"id" => id}, socket) do
-    member = Ash.get!(Mv.Membership.Member, id)
-    Ash.destroy!(member)
-
-    {:noreply, stream_delete(socket, :members, member)}
-  end
-end

lib/mv_web/member_live/show.ex

@@ -1,94 +0,0 @@
-defmodule MvWeb.MemberLive.Show do
-  use MvWeb, :live_view
-  import Ash.Query
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <.header>
-      {@member.first_name} {@member.last_name}
-      <:subtitle>{gettext("This is a member record from your database.")}</:subtitle>
-
-      <:actions>
-        <.link patch={~p"/members/#{@member}/show/edit"} phx-click={JS.push_focus()}>
-          <.button>{gettext("Edit member")}</.button>
-        </.link>
-      </:actions>
-    </.header>
-
-    <.list>
-      <:item title={gettext("Id")}>{@member.id}</:item>
-      <:item title={gettext("First Name")}>{@member.first_name}</:item>
-      <:item title={gettext("Last Name")}>{@member.last_name}</:item>
-      <:item title={gettext("Email")}>{@member.email}</:item>
-      <:item title={gettext("Birth Date")}>{@member.birth_date}</:item>
-      <:item title={gettext("Paid")}>
-        {if @member.paid, do: gettext("Yes"), else: gettext("No")}
-      </:item>
-      <:item title={gettext("Phone Number")}>{@member.phone_number}</:item>
-      <:item title={gettext("Join Date")}>{@member.join_date}</:item>
-      <:item title={gettext("Exit Date")}>{@member.exit_date}</:item>
-      <:item title={gettext("Notes")}>{@member.notes}</:item>
-      <:item title={gettext("City")}>{@member.city}</:item>
-      <:item title={gettext("Street")}>{@member.street}</:item>
-      <:item title={gettext("House Number")}>{@member.house_number}</:item>
-      <:item title={gettext("Postal Code")}>{@member.postal_code}</:item>
-    </.list>
-
-    <h3 class="mt-8 mb-2 text-lg font-semibold">{gettext("Custom Properties")}</h3>
-    <.generic_list items={
-      Enum.map(@member.properties, fn p ->
-        {
-          # name
-          p.property_type && p.property_type.name,
-          # value
-          case p.value do
-            %{value: v} -> v
-            v -> v
-          end
-        }
-      end)
-    } />
-    <.back navigate={~p"/members"}>{gettext("Back to members")}</.back>
-
-    <.modal
-      :if={@live_action == :edit}
-      id="member-modal"
-      show
-      on_cancel={JS.patch(~p"/members/#{@member}")}
-    >
-      <.live_component
-        module={MvWeb.MemberLive.FormComponent}
-        id={@member.id}
-        title={@page_title}
-        action={@live_action}
-        member={@member}
-        patch={~p"/members/#{@member}"}
-      />
-    </.modal>
-    """
-  end
-
-  @impl true
-  def mount(_params, _session, socket) do
-    {:ok, socket}
-  end
-
-  @impl true
-  def handle_params(%{"id" => id}, _, socket) do
-    query =
-      Mv.Membership.Member
-      |> filter(id == ^id)
-      |> load(properties: [:property_type])
-
-    member = Ash.read_one!(query)
-
-    {:noreply,
-     socket
-     |> assign(:page_title, page_title(socket.assigns.live_action))
-     |> assign(:member, member)}
-  end
-
-  defp page_title(:show), do: gettext("Show Member")
-  defp page_title(:edit), do: gettext("Edit Member")
-end

lib/mv_web/property_live/form_component.ex

@@ -1,77 +0,0 @@
-defmodule MvWeb.PropertyLive.FormComponent do
-  use MvWeb, :live_component
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <div>
-      <.header>
-        {@title}
-        <:subtitle>Use this form to manage property records in your database.</:subtitle>
-      </.header>
-
-      <.simple_form
-        for={@form}
-        id="property-form"
-        phx-target={@myself}
-        phx-change="validate"
-        phx-submit="save"
-      >
-        <.input field={@form[:value]} type="text" label="Value" /><.input
-          field={@form[:member_id]}
-          type="text"
-          label="Member"
-        /><.input field={@form[:property_type_id]} type="text" label="Property type" />
-
-        <:actions>
-          <.button phx-disable-with="Saving...">Save Property</.button>
-        </:actions>
-      </.simple_form>
-    </div>
-    """
-  end
-
-  @impl true
-  def update(assigns, socket) do
-    {:ok,
-     socket
-     |> assign(assigns)
-     |> assign_form()}
-  end
-
-  @impl true
-  def handle_event("validate", %{"property" => property_params}, socket) do
-    {:noreply,
-     assign(socket, form: AshPhoenix.Form.validate(socket.assigns.form, property_params))}
-  end
-
-  def handle_event("save", %{"property" => property_params}, socket) do
-    case AshPhoenix.Form.submit(socket.assigns.form, params: property_params) do
-      {:ok, property} ->
-        notify_parent({:saved, property})
-
-        socket =
-          socket
-          |> put_flash(:info, "Property #{socket.assigns.form.source.type}d successfully")
-          |> push_patch(to: socket.assigns.patch)
-
-        {:noreply, socket}
-
-      {:error, form} ->
-        {:noreply, assign(socket, form: form)}
-    end
-  end
-
-  defp notify_parent(msg), do: send(self(), {__MODULE__, msg})
-
-  defp assign_form(%{assigns: %{property: property}} = socket) do
-    form =
-      if property do
-        AshPhoenix.Form.for_update(property, :update, as: "property")
-      else
-        AshPhoenix.Form.for_create(Mv.Membership.Property, :create, as: "property")
-      end
-
-    assign(socket, form: to_form(form))
-  end
-end

lib/mv_web/property_live/index.ex

@@ -1,99 +0,0 @@
-defmodule MvWeb.PropertyLive.Index do
-  use MvWeb, :live_view
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <.header>
-      Listing Properties
-      <:actions>
-        <.link patch={~p"/properties/new"}>
-          <.button>New Property</.button>
-        </.link>
-      </:actions>
-    </.header>
-
-    <.table
-      id="properties"
-      rows={@streams.properties}
-      row_click={fn {_id, property} -> JS.navigate(~p"/properties/#{property}") end}
-    >
-      <:col :let={{_id, property}} label="Id">{property.id}</:col>
-
-      <:action :let={{_id, property}}>
-        <div class="sr-only">
-          <.link navigate={~p"/properties/#{property}"}>Show</.link>
-        </div>
-
-        <.link patch={~p"/properties/#{property}/edit"}>Edit</.link>
-      </:action>
-
-      <:action :let={{id, property}}>
-        <.link
-          phx-click={JS.push("delete", value: %{id: property.id}) |> hide("##{id}")}
-          data-confirm="Are you sure?"
-        >
-          Delete
-        </.link>
-      </:action>
-    </.table>
-
-    <.modal
-      :if={@live_action in [:new, :edit]}
-      id="property-modal"
-      show
-      on_cancel={JS.patch(~p"/properties")}
-    >
-      <.live_component
-        module={MvWeb.PropertyLive.FormComponent}
-        id={(@property && @property.id) || :new}
-        title={@page_title}
-        action={@live_action}
-        property={@property}
-        patch={~p"/properties"}
-      />
-    </.modal>
-    """
-  end
-
-  @impl true
-  def mount(_params, _session, socket) do
-    {:ok, stream(socket, :properties, Ash.read!(Mv.Membership.Property))}
-  end
-
-  @impl true
-  def handle_params(params, _url, socket) do
-    {:noreply, apply_action(socket, socket.assigns.live_action, params)}
-  end
-
-  defp apply_action(socket, :edit, %{"id" => id}) do
-    socket
-    |> assign(:page_title, "Edit Property")
-    |> assign(:property, Ash.get!(Mv.Membership.Property, id))
-  end
-
-  defp apply_action(socket, :new, _params) do
-    socket
-    |> assign(:page_title, "New Property")
-    |> assign(:property, nil)
-  end
-
-  defp apply_action(socket, :index, _params) do
-    socket
-    |> assign(:page_title, "Listing Properties")
-    |> assign(:property, nil)
-  end
-
-  @impl true
-  def handle_info({MvWeb.PropertyLive.FormComponent, {:saved, property}}, socket) do
-    {:noreply, stream_insert(socket, :properties, property)}
-  end
-
-  @impl true
-  def handle_event("delete", %{"id" => id}, socket) do
-    property = Ash.get!(Mv.Membership.Property, id)
-    Ash.destroy!(property)
-
-    {:noreply, stream_delete(socket, :properties, property)}
-  end
-end

lib/mv_web/property_live/show.ex

@@ -1,57 +0,0 @@
-defmodule MvWeb.PropertyLive.Show do
-  use MvWeb, :live_view
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <.header>
-      Property {@property.id}
-      <:subtitle>This is a property record from your database.</:subtitle>
-
-      <:actions>
-        <.link patch={~p"/properties/#{@property}/show/edit"} phx-click={JS.push_focus()}>
-          <.button>Edit property</.button>
-        </.link>
-      </:actions>
-    </.header>
-
-    <.list>
-      <:item title="Id">{@property.id}</:item>
-    </.list>
-
-    <.back navigate={~p"/properties"}>Back to properties</.back>
-
-    <.modal
-      :if={@live_action == :edit}
-      id="property-modal"
-      show
-      on_cancel={JS.patch(~p"/properties/#{@property}")}
-    >
-      <.live_component
-        module={MvWeb.PropertyLive.FormComponent}
-        id={@property.id}
-        title={@page_title}
-        action={@live_action}
-        property={@property}
-        patch={~p"/properties/#{@property}"}
-      />
-    </.modal>
-    """
-  end
-
-  @impl true
-  def mount(_params, _session, socket) do
-    {:ok, socket}
-  end
-
-  @impl true
-  def handle_params(%{"id" => id}, _, socket) do
-    {:noreply,
-     socket
-     |> assign(:page_title, page_title(socket.assigns.live_action))
-     |> assign(:property, Ash.get!(Mv.Membership.Property, id))}
-  end
-
-  defp page_title(:show), do: "Show Property"
-  defp page_title(:edit), do: "Edit Property"
-end

lib/mv_web/property_type_live/form_component.ex

@@ -1,81 +0,0 @@
-defmodule MvWeb.PropertyTypeLive.FormComponent do
-  use MvWeb, :live_component
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <div>
-      <.header>
-        {@title}
-        <:subtitle>Use this form to manage property_type records in your database.</:subtitle>
-      </.header>
-
-      <.simple_form
-        for={@form}
-        id="property_type-form"
-        phx-target={@myself}
-        phx-change="validate"
-        phx-submit="save"
-      >
-        <.input field={@form[:name]} type="text" label="Name" /><.input
-          field={@form[:type]}
-          type="text"
-          label="Type"
-        /><.input field={@form[:description]} type="text" label="Description" /><.input
-          field={@form[:immutable]}
-          type="checkbox"
-          label="Immutable"
-        /><.input field={@form[:required]} type="checkbox" label="Required" />
-
-        <:actions>
-          <.button phx-disable-with="Saving...">Save Property type</.button>
-        </:actions>
-      </.simple_form>
-    </div>
-    """
-  end
-
-  @impl true
-  def update(assigns, socket) do
-    {:ok,
-     socket
-     |> assign(assigns)
-     |> assign_form()}
-  end
-
-  @impl true
-  def handle_event("validate", %{"property_type" => property_type_params}, socket) do
-    {:noreply,
-     assign(socket, form: AshPhoenix.Form.validate(socket.assigns.form, property_type_params))}
-  end
-
-  def handle_event("save", %{"property_type" => property_type_params}, socket) do
-    case AshPhoenix.Form.submit(socket.assigns.form, params: property_type_params) do
-      {:ok, property_type} ->
-        notify_parent({:saved, property_type})
-
-        socket =
-          socket
-          |> put_flash(:info, "Property type #{socket.assigns.form.source.type}d successfully")
-          |> push_patch(to: socket.assigns.patch)
-
-        {:noreply, socket}
-
-      {:error, form} ->
-        {:noreply, assign(socket, form: form)}
-    end
-  end
-
-  defp notify_parent(msg), do: send(self(), {__MODULE__, msg})
-
-  defp assign_form(%{assigns: %{property_type: property_type}} = socket) do
-    form =
-      if property_type do
-        AshPhoenix.Form.for_update(property_type, :update, as: "property_type")
-      else
-        AshPhoenix.Form.for_create(Mv.Membership.PropertyType, :create, as: "property_type")
-      end
-
-    assign(socket, form: to_form(form))
-  end
-end

lib/mv_web/property_type_live/index.ex

@@ -1,103 +0,0 @@
-defmodule MvWeb.PropertyTypeLive.Index do
-  use MvWeb, :live_view
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <.header>
-      Listing Property types
-      <:actions>
-        <.link patch={~p"/property_types/new"}>
-          <.button>New Property type</.button>
-        </.link>
-      </:actions>
-    </.header>
-
-    <.table
-      id="property_types"
-      rows={@streams.property_types}
-      row_click={fn {_id, property_type} -> JS.navigate(~p"/property_types/#{property_type}") end}
-    >
-      <:col :let={{_id, property_type}} label="Id">{property_type.id}</:col>
-
-      <:col :let={{_id, property_type}} label="Name">{property_type.name}</:col>
-
-      <:col :let={{_id, property_type}} label="Description">{property_type.description}</:col>
-
-      <:action :let={{_id, property_type}}>
-        <div class="sr-only">
-          <.link navigate={~p"/property_types/#{property_type}"}>Show</.link>
-        </div>
-
-        <.link patch={~p"/property_types/#{property_type}/edit"}>Edit</.link>
-      </:action>
-
-      <:action :let={{id, property_type}}>
-        <.link
-          phx-click={JS.push("delete", value: %{id: property_type.id}) |> hide("##{id}")}
-          data-confirm="Are you sure?"
-        >
-          Delete
-        </.link>
-      </:action>
-    </.table>
-
-    <.modal
-      :if={@live_action in [:new, :edit]}
-      id="property_type-modal"
-      show
-      on_cancel={JS.patch(~p"/property_types")}
-    >
-      <.live_component
-        module={MvWeb.PropertyTypeLive.FormComponent}
-        id={(@property_type && @property_type.id) || :new}
-        title={@page_title}
-        action={@live_action}
-        property_type={@property_type}
-        patch={~p"/property_types"}
-      />
-    </.modal>
-    """
-  end
-
-  @impl true
-  def mount(_params, _session, socket) do
-    {:ok, stream(socket, :property_types, Ash.read!(Mv.Membership.PropertyType))}
-  end
-
-  @impl true
-  def handle_params(params, _url, socket) do
-    {:noreply, apply_action(socket, socket.assigns.live_action, params)}
-  end
-
-  defp apply_action(socket, :edit, %{"id" => id}) do
-    socket
-    |> assign(:page_title, "Edit Property type")
-    |> assign(:property_type, Ash.get!(Mv.Membership.PropertyType, id))
-  end
-
-  defp apply_action(socket, :new, _params) do
-    socket
-    |> assign(:page_title, "New Property type")
-    |> assign(:property_type, nil)
-  end
-
-  defp apply_action(socket, :index, _params) do
-    socket
-    |> assign(:page_title, "Listing Property types")
-    |> assign(:property_type, nil)
-  end
-
-  @impl true
-  def handle_info({MvWeb.PropertyTypeLive.FormComponent, {:saved, property_type}}, socket) do
-    {:noreply, stream_insert(socket, :property_types, property_type)}
-  end
-
-  @impl true
-  def handle_event("delete", %{"id" => id}, socket) do
-    property_type = Ash.get!(Mv.Membership.PropertyType, id)
-    Ash.destroy!(property_type)
-
-    {:noreply, stream_delete(socket, :property_types, property_type)}
-  end
-end

lib/mv_web/property_type_live/show.ex

@@ -1,61 +0,0 @@
-defmodule MvWeb.PropertyTypeLive.Show do
-  use MvWeb, :live_view
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <.header>
-      Property type {@property_type.id}
-      <:subtitle>This is a property_type record from your database.</:subtitle>
-
-      <:actions>
-        <.link patch={~p"/property_types/#{@property_type}/show/edit"} phx-click={JS.push_focus()}>
-          <.button>Edit property_type</.button>
-        </.link>
-      </:actions>
-    </.header>
-
-    <.list>
-      <:item title="Id">{@property_type.id}</:item>
-
-      <:item title="Name">{@property_type.name}</:item>
-
-      <:item title="Description">{@property_type.description}</:item>
-    </.list>
-
-    <.back navigate={~p"/property_types"}>Back to property_types</.back>
-
-    <.modal
-      :if={@live_action == :edit}
-      id="property_type-modal"
-      show
-      on_cancel={JS.patch(~p"/property_types/#{@property_type}")}
-    >
-      <.live_component
-        module={MvWeb.PropertyTypeLive.FormComponent}
-        id={@property_type.id}
-        title={@page_title}
-        action={@live_action}
-        property_type={@property_type}
-        patch={~p"/property_types/#{@property_type}"}
-      />
-    </.modal>
-    """
-  end
-
-  @impl true
-  def mount(_params, _session, socket) do
-    {:ok, socket}
-  end
-
-  @impl true
-  def handle_params(%{"id" => id}, _, socket) do
-    {:noreply,
-     socket
-     |> assign(:page_title, page_title(socket.assigns.live_action))
-     |> assign(:property_type, Ash.get!(Mv.Membership.PropertyType, id))}
-  end
-
-  defp page_title(:show), do: "Show Property type"
-  defp page_title(:edit), do: "Edit Property type"
-end

lib/mv_web/router.ex

@@ -50,20 +50,20 @@ defmodule MvWeb.Router do
       get "/", PageController, :home
 
       live "/members", MemberLive.Index, :index
-      live "/members/new", MemberLive.Index, :new
-      live "/members/:id/edit", MemberLive.Index, :edit
+      live "/members/new", MemberLive.Form, :new
+      live "/members/:id/edit", MemberLive.Form, :edit
       live "/members/:id", MemberLive.Show, :show
       live "/members/:id/show/edit", MemberLive.Show, :edit
 
       live "/property_types", PropertyTypeLive.Index, :index
-      live "/property_types/new", PropertyTypeLive.Index, :new
-      live "/property_types/:id/edit", PropertyTypeLive.Index, :edit
+      live "/property_types/new", PropertyTypeLive.Form, :new
+      live "/property_types/:id/edit", PropertyTypeLive.Form, :edit
       live "/property_types/:id", PropertyTypeLive.Show, :show
       live "/property_types/:id/show/edit", PropertyTypeLive.Show, :edit
 
       live "/properties", PropertyLive.Index, :index
-      live "/properties/new", PropertyLive.Index, :new
-      live "/properties/:id/edit", PropertyLive.Index, :edit
+      live "/properties/new", PropertyLive.Form, :new
+      live "/properties/:id/edit", PropertyLive.Form, :edit
       live "/properties/:id", PropertyLive.Show, :show
       live "/properties/:id/show/edit", PropertyLive.Show, :edit