438 lines
15 KiB
Elixir
438 lines
15 KiB
Elixir
defmodule MvWeb.UserLive.Form do
|
|
use MvWeb, :live_view
|
|
import MvWeb.MemberFormComponent, only: [member_form: 1]
|
|
|
|
@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 user records in your database.")}</:subtitle>
|
|
</.header>
|
|
|
|
<.form for={@form} id="user-form" phx-change="validate" phx-submit="save">
|
|
<.input field={@form[:email]} label={gettext("Email")} required type="email" />
|
|
|
|
<!-- Member Assignment Section -->
|
|
<%= if !@user || !@user.member do %>
|
|
<div class="mt-6 space-y-4">
|
|
<h3 class="text-lg font-medium">{gettext("Member Assignment")}</h3>
|
|
|
|
<label class="flex items-center space-x-2">
|
|
<input
|
|
type="radio"
|
|
name="member_assignment_mode"
|
|
value="create_new"
|
|
phx-click="set_member_mode"
|
|
phx-value-mode="create_new"
|
|
checked={@member_assignment_mode == "create_new"}
|
|
class="radio radio-sm"
|
|
/>
|
|
<span class="text-sm">
|
|
{gettext("Create new member with custom data")}
|
|
</span>
|
|
</label>
|
|
|
|
<label class="flex items-center space-x-2">
|
|
<input
|
|
type="radio"
|
|
name="member_assignment_mode"
|
|
value="assign_existing"
|
|
phx-click="set_member_mode"
|
|
phx-value-mode="assign_existing"
|
|
checked={@member_assignment_mode == "assign_existing"}
|
|
class="radio radio-sm"
|
|
/>
|
|
<span class="text-sm">
|
|
{gettext("Assign to existing member")}
|
|
</span>
|
|
</label>
|
|
|
|
<%= if @member_assignment_mode == "assign_existing" do %>
|
|
<div class="ml-6 mt-2">
|
|
<.input
|
|
field={@form[:member_id]}
|
|
label={gettext("Select Member")}
|
|
type="select"
|
|
options={@available_members}
|
|
prompt={gettext("Choose a member...")}
|
|
/>
|
|
</div>
|
|
<% end %>
|
|
|
|
<%= if @member_assignment_mode == "create_new" do %>
|
|
<div class="ml-6 mt-4 p-4 bg-gray-50 rounded-lg">
|
|
<%= if @form[:member] do %>
|
|
<.inputs_for :let={f_member} field={@form[:member]}>
|
|
<.member_form form={f_member} property_types={@property_types} />
|
|
</.inputs_for>
|
|
<% else %>
|
|
<p class="text-sm text-gray-600">{gettext("Member form will be available after saving the user.")}</p>
|
|
<% end %>
|
|
</div>
|
|
<% end %>
|
|
</div>
|
|
<% else %>
|
|
<div class="mt-6 space-y-4">
|
|
<h3 class="text-lg font-medium">{gettext("Member Assignment")}</h3>
|
|
<p class="text-sm text-gray-600">
|
|
{gettext("Edit assigned member")}: {@user.member.first_name} {@user.member.last_name} ({@user.member.email})
|
|
</p>
|
|
<%= if @member_form do %>
|
|
<div class="ml-6 mt-4 p-4 bg-gray-50 rounded-lg">
|
|
<.form for={@member_form} id="member-form" phx-change="validate_member" phx-submit="save_member">
|
|
<.member_form form={@member_form} property_types={@property_types} />
|
|
<.button type="submit" variant="primary" class="mt-4">
|
|
{gettext("Save Member")}
|
|
</.button>
|
|
</.form>
|
|
</div>
|
|
<% end %>
|
|
</div>
|
|
<% end %>
|
|
|
|
<!-- Password Section -->
|
|
<div class="mt-6">
|
|
<label class="flex items-center space-x-2">
|
|
<input
|
|
type="checkbox"
|
|
name="set_password"
|
|
phx-click="toggle_password_section"
|
|
checked={@show_password_fields}
|
|
class="checkbox checkbox-sm"
|
|
/>
|
|
<span class="text-sm font-medium">
|
|
{if @user, do: gettext("Change Password"), else: gettext("Set Password")}
|
|
</span>
|
|
</label>
|
|
|
|
<%= if @show_password_fields do %>
|
|
<div class="mt-4 space-y-4 p-4 bg-gray-50 rounded-lg">
|
|
<.input
|
|
field={@form[:password]}
|
|
label={gettext("Password")}
|
|
type="password"
|
|
required
|
|
autocomplete="new-password"
|
|
/>
|
|
|
|
<!-- Only show password confirmation for new users (register_with_password) -->
|
|
<%= if !@user do %>
|
|
<.input
|
|
field={@form[:password_confirmation]}
|
|
label={gettext("Confirm Password")}
|
|
type="password"
|
|
required
|
|
autocomplete="new-password"
|
|
/>
|
|
<% end %>
|
|
|
|
<div class="text-sm text-gray-600">
|
|
<p><strong>{gettext("Password requirements")}:</strong></p>
|
|
<ul class="list-disc list-inside text-xs mt-1 space-y-1">
|
|
<li>{gettext("At least 8 characters")}</li>
|
|
<li>{gettext("Include both letters and numbers")}</li>
|
|
<li>{gettext("Consider using special characters")}</li>
|
|
</ul>
|
|
</div>
|
|
|
|
<%= if @user do %>
|
|
<div class="mt-3 p-3 bg-orange-50 border border-orange-200 rounded">
|
|
<p class="text-sm text-orange-800">
|
|
<strong>{gettext("Admin Note")}:</strong> {gettext(
|
|
"As an administrator, you can directly set a new password for this user using the same secure Ash Authentication system."
|
|
)}
|
|
</p>
|
|
</div>
|
|
<% end %>
|
|
</div>
|
|
<% else %>
|
|
<%= if @user do %>
|
|
<div class="mt-4 p-4 bg-blue-50 rounded-lg">
|
|
<p class="text-sm text-blue-800">
|
|
<strong>{gettext("Note")}:</strong> {gettext(
|
|
"Check 'Change Password' above to set a new password for this user."
|
|
)}
|
|
</p>
|
|
</div>
|
|
<% else %>
|
|
<div class="mt-4 p-4 bg-yellow-50 rounded-lg">
|
|
<p class="text-sm text-yellow-800">
|
|
<strong>{gettext("Note")}:</strong> {gettext(
|
|
"User will be created without a password. Check 'Set Password' to add one."
|
|
)}
|
|
</p>
|
|
</div>
|
|
<% end %>
|
|
<% end %>
|
|
</div>
|
|
|
|
<.button phx-disable-with={gettext("Saving...")} variant="primary">
|
|
{gettext("Save User")}
|
|
</.button>
|
|
<.button navigate={return_path(@return_to, @user)}>{gettext("Cancel")}</.button>
|
|
</.form>
|
|
</Layouts.app>
|
|
"""
|
|
end
|
|
|
|
@impl true
|
|
def mount(params, _session, socket) do
|
|
user =
|
|
case params["id"] do
|
|
nil -> nil
|
|
id ->
|
|
user = Ash.get!(Mv.Accounts.User, id, domain: Mv.Accounts)
|
|
|> Ash.load!(:member)
|
|
|
|
if user.member do
|
|
{:ok, member_with_properties} = Ash.load(user.member, properties: [:property_type])
|
|
%{user | member: member_with_properties}
|
|
else
|
|
user
|
|
end
|
|
end
|
|
|
|
action = if is_nil(user), do: gettext("New"), else: gettext("Edit")
|
|
page_title = action <> " " <> gettext("User")
|
|
|
|
# Load available members that have no user assigned
|
|
{:ok, available_members} = Mv.Membership.list_members()
|
|
available_members_with_user = Ash.load!(available_members, :user)
|
|
|
|
available_member_options =
|
|
available_members_with_user
|
|
|> Enum.filter(fn member -> is_nil(member.user) end)
|
|
|> Enum.map(fn member ->
|
|
{"#{member.first_name} #{member.last_name} (#{member.email})", member.id}
|
|
end)
|
|
|
|
# Load PropertyTypes for MemberForm
|
|
{: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_form = AshPhoenix.Form.for_create(
|
|
Mv.Membership.Member,
|
|
:create_member,
|
|
domain: Mv.Membership,
|
|
as: "member",
|
|
params: %{"properties" => initial_properties},
|
|
forms: [auto?: true]
|
|
) |> to_form()
|
|
|
|
# Initialize member_form for existing users with members
|
|
member_form = if user && user.member do
|
|
{:ok, member_with_properties} = Ash.load(user.member, properties: [:property_type])
|
|
|
|
existing_properties =
|
|
member_with_properties.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_with_properties.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_with_properties,
|
|
:update_member,
|
|
domain: Mv.Membership,
|
|
as: "member",
|
|
params: params,
|
|
forms: [auto?: true]
|
|
)
|
|
|
|
missing_properties = Enum.filter(initial_properties, is_missing_property)
|
|
|
|
Enum.reduce(
|
|
missing_properties,
|
|
form,
|
|
&AshPhoenix.Form.add_form(&2, [:properties], params: &1)
|
|
) |> to_form()
|
|
else
|
|
member_form
|
|
end
|
|
|
|
{:ok,
|
|
socket
|
|
|> assign(:return_to, return_to(params["return_to"]))
|
|
|> assign(user: user)
|
|
|> assign(:page_title, page_title)
|
|
|> assign(:show_password_fields, false)
|
|
|> assign(:member_assignment_mode, "create_new")
|
|
|> assign(:available_members, available_member_options)
|
|
|> assign(:property_types, property_types)
|
|
|> assign(:initial_properties, initial_properties)
|
|
|> assign(:member_form, member_form)
|
|
|> assign_form()}
|
|
end
|
|
|
|
defp return_to("show"), do: "show"
|
|
defp return_to(_), do: "index"
|
|
|
|
@impl true
|
|
def handle_event("toggle_password_section", _params, socket) do
|
|
show_password_fields = !socket.assigns.show_password_fields
|
|
|
|
socket =
|
|
socket
|
|
|> assign(:show_password_fields, show_password_fields)
|
|
|> assign_form()
|
|
|
|
{:noreply, socket}
|
|
end
|
|
|
|
def handle_event("set_member_mode", %{"mode" => mode}, socket) do
|
|
socket =
|
|
socket
|
|
|> assign(:member_assignment_mode, mode)
|
|
|> assign_form()
|
|
|
|
{:noreply, socket}
|
|
end
|
|
|
|
def handle_event("validate", %{"user" => user_params, "member" => member_params}, socket) do
|
|
member_form = AshPhoenix.Form.validate(socket.assigns.member_form.source, member_params) |> to_form()
|
|
user_form = AshPhoenix.Form.validate(socket.assigns.form.source, user_params)
|
|
{:noreply, assign(socket, form: user_form, member_form: member_form)}
|
|
end
|
|
|
|
def handle_event("validate", %{"user" => user_params}, socket) do
|
|
{:noreply, assign(socket, form: AshPhoenix.Form.validate(socket.assigns.form, user_params))}
|
|
end
|
|
|
|
def handle_event("validate_member", %{"member" => member_params}, socket) do
|
|
member_form = AshPhoenix.Form.validate(socket.assigns.member_form.source, member_params) |> to_form()
|
|
{:noreply, assign(socket, member_form: member_form)}
|
|
end
|
|
|
|
def handle_event("save_member", %{"member" => member_params}, socket) do
|
|
case AshPhoenix.Form.submit(socket.assigns.member_form.source, params: member_params) do
|
|
{:ok, member} ->
|
|
# Reload the user with updated member
|
|
user = socket.assigns.user |> Ash.load!(:member)
|
|
socket =
|
|
socket
|
|
|> assign(user: user)
|
|
|> put_flash(:info, "Member updated successfully")
|
|
{:noreply, socket}
|
|
{:error, member_form} ->
|
|
{:noreply, assign(socket, member_form: to_form(member_form))}
|
|
end
|
|
end
|
|
|
|
def handle_event("save", params, socket) do
|
|
user_params = params["user"] || %{}
|
|
case AshPhoenix.Form.submit(socket.assigns.form, params: user_params) do
|
|
{:ok, user} ->
|
|
notify_parent({:saved, user})
|
|
socket =
|
|
socket
|
|
|> put_flash(:info, "User #{socket.assigns.form.source.type}d successfully")
|
|
|> push_navigate(to: return_path(socket.assigns.return_to, user))
|
|
{:noreply, socket}
|
|
{:error, form} ->
|
|
{:noreply, assign(socket, form: form)}
|
|
end
|
|
end
|
|
|
|
defp notify_parent(msg), do: send(self(), {__MODULE__, msg})
|
|
|
|
defp assign_form(%{assigns: %{user: user, show_password_fields: show_password_fields, member_assignment_mode: member_assignment_mode, property_types: property_types}} = socket) do
|
|
form =
|
|
if user do
|
|
# For existing users, use admin password action if password fields are shown
|
|
action = if show_password_fields, do: :admin_set_password, else: :update_user
|
|
|
|
if member_assignment_mode == "create_new" do
|
|
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)
|
|
params = %{"member" => %{"properties" => initial_properties}}
|
|
AshPhoenix.Form.for_update(user, action,
|
|
as: "user",
|
|
actor: socket.assigns.current_user,
|
|
domain: Mv.Accounts,
|
|
params: params,
|
|
forms: [auto?: true]
|
|
)
|
|
else
|
|
AshPhoenix.Form.for_update(user, action,
|
|
as: "user",
|
|
actor: socket.assigns.current_user,
|
|
domain: Mv.Accounts
|
|
)
|
|
end
|
|
else
|
|
# For new users, use password registration if password fields are shown
|
|
action = if show_password_fields, do: :register_with_password, else: :create_user
|
|
|
|
if member_assignment_mode == "create_new" do
|
|
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)
|
|
params = %{"member" => %{"properties" => initial_properties}}
|
|
AshPhoenix.Form.for_create(Mv.Accounts.User, action,
|
|
as: "user",
|
|
actor: socket.assigns.current_user,
|
|
domain: Mv.Accounts,
|
|
accept: [:email, :password, :password_confirmation],
|
|
params: params,
|
|
forms: [auto?: true]
|
|
)
|
|
else
|
|
AshPhoenix.Form.for_create(Mv.Accounts.User, action,
|
|
as: "user",
|
|
actor: socket.assigns.current_user,
|
|
domain: Mv.Accounts,
|
|
accept: if(member_assignment_mode == "assign_existing", do: [:email, :member_id], else: [:email])
|
|
)
|
|
end
|
|
end
|
|
|
|
assign(socket, form: to_form(form))
|
|
end
|
|
|
|
defp return_path("index", _user), do: ~p"/users"
|
|
defp return_path("show", user), do: ~p"/users/#{user.id}"
|
|
end
|