251 lines
8.2 KiB
Elixir
251 lines
8.2 KiB
Elixir
defmodule MvWeb.PropertyLive.Form do
|
|
use MvWeb, :live_view
|
|
|
|
@impl true
|
|
def render(assigns) do
|
|
~H"""
|
|
<Layouts.app flash={@flash} current_user={@current_user}>
|
|
<.header>
|
|
{@page_title}
|
|
<: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">
|
|
<!-- Property Type Selection -->
|
|
<.input
|
|
field={@form[:property_type_id]}
|
|
type="select"
|
|
label={gettext("Property type")}
|
|
options={property_type_options(@property_types)}
|
|
prompt={gettext("Choose a property type")}
|
|
/>
|
|
|
|
<!-- Member Selection -->
|
|
<.input
|
|
field={@form[:member_id]}
|
|
type="select"
|
|
label={gettext("Member")}
|
|
options={member_options(@members)}
|
|
prompt={gettext("Choose a member")}
|
|
/>
|
|
|
|
<!-- Value Input - handles Union type -->
|
|
<%= if @selected_property_type do %>
|
|
<.union_value_input form={@form} property_type={@selected_property_type} />
|
|
<% else %>
|
|
<div class="text-sm text-gray-600">
|
|
{gettext("Please select a property type first")}
|
|
</div>
|
|
<% end %>
|
|
|
|
<.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>
|
|
"""
|
|
end
|
|
|
|
# Helper function for Union-Value Input
|
|
defp union_value_input(assigns) do
|
|
# Extract the current value from the Property
|
|
current_value = extract_current_value(assigns.form.data, assigns.property_type.value_type)
|
|
assigns = assign(assigns, :current_value, current_value)
|
|
|
|
~H"""
|
|
<div class="space-y-2">
|
|
<label class="block text-sm font-medium text-gray-700">
|
|
{gettext("Value")}
|
|
</label>
|
|
|
|
<%= case @property_type.value_type do %>
|
|
<% :string -> %>
|
|
<.inputs_for :let={value_form} field={@form[:value]}>
|
|
<.input field={value_form[:value]} type="text" label="" value={@current_value} />
|
|
<input type="hidden" name={value_form[:_union_type].name} value="string" />
|
|
</.inputs_for>
|
|
<% :integer -> %>
|
|
<.inputs_for :let={value_form} field={@form[:value]}>
|
|
<.input field={value_form[:value]} type="number" label="" value={@current_value} />
|
|
<input type="hidden" name={value_form[:_union_type].name} value="integer" />
|
|
</.inputs_for>
|
|
<% :boolean -> %>
|
|
<.inputs_for :let={value_form} field={@form[:value]}>
|
|
<.input field={value_form[:value]} type="checkbox" label="" checked={@current_value} />
|
|
<input type="hidden" name={value_form[:_union_type].name} value="boolean" />
|
|
</.inputs_for>
|
|
<% :date -> %>
|
|
<.inputs_for :let={value_form} field={@form[:value]}>
|
|
<.input
|
|
field={value_form[:value]}
|
|
type="date"
|
|
label=""
|
|
value={format_date_value(@current_value)}
|
|
/>
|
|
<input type="hidden" name={value_form[:_union_type].name} value="date" />
|
|
</.inputs_for>
|
|
<% :email -> %>
|
|
<.inputs_for :let={value_form} field={@form[:value]}>
|
|
<.input field={value_form[:value]} type="email" label="" value={@current_value} />
|
|
<input type="hidden" name={value_form[:_union_type].name} value="email" />
|
|
</.inputs_for>
|
|
<% _ -> %>
|
|
<div class="text-sm text-red-600">
|
|
{gettext("Unsupported value type: %{type}", type: @property_type.value_type)}
|
|
</div>
|
|
<% end %>
|
|
</div>
|
|
"""
|
|
end
|
|
|
|
# Helper function to extract the current value from the Property
|
|
defp extract_current_value(
|
|
%Mv.Membership.Property{value: %Ash.Union{value: value}},
|
|
_value_type
|
|
) do
|
|
value
|
|
end
|
|
|
|
defp extract_current_value(_data, _value_type) do
|
|
nil
|
|
end
|
|
|
|
# Helper function to format Date values for HTML input
|
|
defp format_date_value(%Date{} = date) do
|
|
Date.to_iso8601(date)
|
|
end
|
|
|
|
defp format_date_value(nil), do: ""
|
|
|
|
defp format_date_value(date) when is_binary(date) do
|
|
case Date.from_iso8601(date) do
|
|
{:ok, parsed_date} -> Date.to_iso8601(parsed_date)
|
|
_ -> ""
|
|
end
|
|
end
|
|
|
|
defp format_date_value(_), do: ""
|
|
|
|
@impl true
|
|
def mount(params, _session, socket) do
|
|
property =
|
|
case params["id"] do
|
|
nil -> nil
|
|
id -> Ash.get!(Mv.Membership.Property, id) |> Ash.load!([:property_type])
|
|
end
|
|
|
|
action = if is_nil(property), do: "New", else: "Edit"
|
|
page_title = action <> " " <> "Property"
|
|
|
|
# Load all PropertyTypes and Members for the selection fields
|
|
property_types = Ash.read!(Mv.Membership.PropertyType)
|
|
members = Ash.read!(Mv.Membership.Member)
|
|
|
|
{:ok,
|
|
socket
|
|
|> assign(:return_to, return_to(params["return_to"]))
|
|
|> assign(property: property)
|
|
|> assign(:page_title, page_title)
|
|
|> assign(:property_types, property_types)
|
|
|> assign(:members, members)
|
|
|> assign(:selected_property_type, property && property.property_type)
|
|
|> assign_form()}
|
|
end
|
|
|
|
defp return_to("show"), do: "show"
|
|
defp return_to(_), do: "index"
|
|
|
|
@impl true
|
|
def handle_event("validate", %{"property" => property_params}, socket) do
|
|
# Find the selected PropertyType
|
|
selected_property_type =
|
|
case property_params["property_type_id"] do
|
|
"" -> nil
|
|
nil -> nil
|
|
id -> Enum.find(socket.assigns.property_types, &(&1.id == id))
|
|
end
|
|
|
|
# Set the Union type based on the selected PropertyType
|
|
updated_params =
|
|
if selected_property_type do
|
|
union_type = to_string(selected_property_type.value_type)
|
|
put_in(property_params, ["value", "_union_type"], union_type)
|
|
else
|
|
property_params
|
|
end
|
|
|
|
{:noreply,
|
|
socket
|
|
|> assign(:selected_property_type, selected_property_type)
|
|
|> assign(form: AshPhoenix.Form.validate(socket.assigns.form, updated_params))}
|
|
end
|
|
|
|
def handle_event("save", %{"property" => property_params}, socket) do
|
|
# Set the Union type based on the selected PropertyType
|
|
updated_params =
|
|
if socket.assigns.selected_property_type do
|
|
union_type = to_string(socket.assigns.selected_property_type.value_type)
|
|
put_in(property_params, ["value", "_union_type"], union_type)
|
|
else
|
|
property_params
|
|
end
|
|
|
|
case AshPhoenix.Form.submit(socket.assigns.form, params: updated_params) 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, gettext("Property %{action} successfully", action: action))
|
|
|> push_navigate(to: return_path(socket.assigns.return_to, property))
|
|
|
|
{: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
|
|
# Determine the Union type based on the property_type
|
|
union_type = property.property_type && property.property_type.value_type
|
|
|
|
params =
|
|
if union_type do
|
|
%{"value" => %{"_union_type" => to_string(union_type)}}
|
|
else
|
|
%{}
|
|
end
|
|
|
|
AshPhoenix.Form.for_update(property, :update, as: "property", params: params)
|
|
else
|
|
AshPhoenix.Form.for_create(Mv.Membership.Property, :create, as: "property")
|
|
end
|
|
|
|
assign(socket, form: to_form(form))
|
|
end
|
|
|
|
defp return_path("index", _property), do: ~p"/properties"
|
|
defp return_path("show", property), do: ~p"/properties/#{property.id}"
|
|
|
|
# Helper functions for selection options
|
|
defp property_type_options(property_types) do
|
|
Enum.map(property_types, &{&1.name, &1.id})
|
|
end
|
|
|
|
defp member_options(members) do
|
|
Enum.map(members, &{"#{&1.first_name} #{&1.last_name}", &1.id})
|
|
end
|
|
end
|