Free help and thanks
diff --git a/lib/who_need_help_web/live/activity_live/index.ex b/lib/who_need_help_web/live/activity_live/index.ex
new file mode 100644
index 0000000..40e6dfe
--- /dev/null
+++ b/lib/who_need_help_web/live/activity_live/index.ex
@@ -0,0 +1,161 @@
+defmodule WhoNeedHelpWeb.ActivityLive.Index do
+ use WhoNeedHelpWeb, :live_view
+
+ alias WhoNeedHelp.{Activities, Catalog}
+ alias WhoNeedHelp.Activities.Activity
+
+ @impl true
+ def mount(_params, _session, socket) do
+ if connected?(socket), do: Activities.subscribe()
+
+ {:ok,
+ socket
+ |> assign(:filters, %{"category_id" => ""})
+ |> load()}
+ end
+
+ @impl true
+ def handle_info({event, _activity}, socket)
+ when event in [:activity_created, :activity_updated] do
+ {:noreply, load(socket)}
+ end
+
+ @impl true
+ def handle_event("filter", %{"filters" => filters}, socket) do
+ {:noreply, socket |> assign(:filters, filters) |> load()}
+ end
+
+ defp load(socket) do
+ activities =
+ Activities.list_open_activities(socket.assigns.current_scope, socket.assigns.filters)
+
+ socket
+ |> assign(:page_title, "Activities")
+ |> assign(:activities, activities)
+ |> assign(:my_activities, Activities.list_my_activities(socket.assigns.current_scope))
+ |> assign(:categories, Catalog.list_categories(:activity))
+ |> assign(:filter_form, to_form(socket.assigns.filters, as: :filters))
+ |> assign(:markers, Jason.encode!(Enum.flat_map(activities, &List.wrap(marker(&1)))))
+ end
+
+ defp marker(activity) do
+ case Activity.public_coordinates(activity) do
+ nil ->
+ nil
+
+ coordinates ->
+ Map.merge(coordinates, %{
+ id: activity.id,
+ title: activity.title,
+ location: activity.location_label
+ })
+ end
+ end
+
+ @impl true
+ def render(assigns) do
+ ~H"""
+
+
+
+
OPTIONAL SOCIAL PLANS
+
Find people to join
+
+ Coffee, cinema, walks, and hikes are separate from urgent help and never affect helper ratings.
+
+
+ <.link navigate={~p"/activities/new"} class="btn btn-info">Create activity
+
+ <.icon name="hero-shield-check" class="size-5" />
+
+ Meet in public first, keep exact details inside the approved group, and leave or report anything that feels unsafe.
+
+
+
+ <.form
+ for={@filter_form}
+ phx-change="filter"
+ class="mt-5 rounded-2xl bg-base-200 p-4"
+ >
+ <.input
+ field={@filter_form[:category_id]}
+ type="select"
+ label="Activity type"
+ options={[
+ {"All activities", ""}
+ | Enum.map(
+ @categories,
+ &{Catalog.category_path(&1, @current_scope.user.locale), &1.id}
+ )
+ ]}
+ />
+
+
+
+
+
+
No open activities yet
+
Create a clear plan in a public place.
+
+
+ <.link
+ :for={activity <- @activities}
+ navigate={~p"/activities/#{activity.id}"}
+ class="block rounded-3xl border border-base-300 bg-base-100 p-6 transition hover:border-info/50"
+ >
+
+
+
+
+ {Catalog.category_path(activity.category, @current_scope.user.locale)}
+
+
+ {Enum.count(activity.participants, &(&1.status == :approved))}/{activity.capacity}
+
+
+
{activity.title}
+
{activity.description}
+
+ <.icon name="hero-chevron-right" class="mt-2 size-5 shrink-0" />
+
+
+ 📍 {activity.location_label}
+ 🕒 {Calendar.strftime(activity.starts_at, "%d %b, %H:%M UTC")}
+ by {activity.creator.display_name || "Community member"}
+
+
+
+
+
+
+ Your activities
+
+ <.link
+ :for={activity <- @my_activities}
+ navigate={~p"/activities/#{activity.id}"}
+ class="rounded-2xl bg-base-200 p-4"
+ >
+
{activity.status}
+
{activity.title}
+
+
+
+ """
+ end
+end
diff --git a/lib/who_need_help_web/live/activity_live/new.ex b/lib/who_need_help_web/live/activity_live/new.ex
new file mode 100644
index 0000000..fb1301d
--- /dev/null
+++ b/lib/who_need_help_web/live/activity_live/new.ex
@@ -0,0 +1,278 @@
+defmodule WhoNeedHelpWeb.ActivityLive.New do
+ use WhoNeedHelpWeb, :live_view
+
+ alias WhoNeedHelp.{Activities, Catalog}
+ alias WhoNeedHelp.Activities.Activity
+
+ @impl true
+ def mount(_params, _session, socket) do
+ {:ok,
+ socket
+ |> assign(:page_title, "Create activity")
+ |> assign(:categories, Catalog.list_categories(:activity))
+ |> assign(:selected_category, nil)
+ |> assign(:structured_fields, [])
+ |> assign(:form, to_form(Activities.change_activity(%Activity{})))}
+ end
+
+ @impl true
+ def handle_event("validate", %{"activity" => params}, socket) do
+ changeset =
+ %Activity{}
+ |> Activities.change_activity(normalize_datetimes(params))
+ |> Map.put(:action, :validate)
+
+ {:noreply,
+ socket
+ |> assign(:form, to_form(changeset))
+ |> assign_category(params)}
+ end
+
+ def handle_event("save", %{"activity" => params}, socket) do
+ case Activities.create_activity(socket.assigns.current_scope, normalize_datetimes(params)) do
+ {:ok, activity} ->
+ {:noreply,
+ socket
+ |> put_flash(:info, "Activity published. You approve every participant.")
+ |> push_navigate(to: ~p"/activities/#{activity.id}")}
+
+ {:error, %Ecto.Changeset{} = changeset} ->
+ {:noreply,
+ socket
+ |> assign(:form, to_form(changeset))
+ |> assign_category(params)}
+
+ {:error, reason} ->
+ {:noreply, put_flash(socket, :error, error_message(reason))}
+ end
+ end
+
+ defp normalize_datetimes(params) do
+ Enum.reduce(["starts_at", "join_deadline"], params, fn key, normalized ->
+ case normalized[key] do
+ value when is_binary(value) ->
+ parsed =
+ case NaiveDateTime.from_iso8601(
+ value <> if(String.length(value) == 16, do: ":00", else: "")
+ ) do
+ {:ok, naive} -> DateTime.from_naive!(naive, "Etc/UTC")
+ _ -> value
+ end
+
+ Map.put(normalized, key, parsed)
+
+ _ ->
+ normalized
+ end
+ end)
+ end
+
+ defp assign_category(socket, params) do
+ category = Enum.find(socket.assigns.categories, &(&1.id == params["category_id"]))
+
+ socket
+ |> assign(:selected_category, category)
+ |> assign(:structured_fields, if(category, do: Catalog.structured_fields(category), else: []))
+ end
+
+ defp field_label(field, locale) do
+ labels = field["label"] || %{}
+ labels[to_string(locale)] || labels["en"] || field["key"]
+ end
+
+ defp option_label(option, locale) when is_map(option) do
+ labels = option["label"] || %{}
+ labels[to_string(locale)] || labels["en"] || option["value"]
+ end
+
+ defp option_label(option, _locale), do: to_string(option)
+ defp option_value(option) when is_map(option), do: option["value"]
+ defp option_value(option), do: option
+
+ defp structured_value(form, key) do
+ form.params |> Map.get("structured_data", %{}) |> Map.get(key)
+ end
+
+ defp error_message(:account_not_eligible),
+ do: "Confirm your email and ensure your account is active before publishing."
+
+ defp error_message(:rate_limited), do: "Too many actions in the configured time window."
+ defp error_message(reason), do: "Could not publish the activity: #{inspect(reason)}"
+
+ @impl true
+ def render(assigns) do
+ ~H"""
+
+
+ <.link navigate={~p"/activities"} class="btn btn-ghost btn-sm mb-4">
+ ← Back to activities
+
+
Create an activity
+
+ Publish a clear public plan. Join requests stay pending until you approve them.
+
+
+
+ <.icon name="hero-exclamation-triangle" class="size-5" />
+
+ Use a public first meeting point. Do not publish a home address, access code, travel document, or other sensitive information.
+
+
+
+ <.form
+ for={@form}
+ id="activity-form"
+ phx-change="validate"
+ phx-submit="save"
+ class="mt-8 space-y-5"
+ >
+ <.input
+ field={@form[:category_id]}
+ type="select"
+ label="Activity type"
+ prompt="Choose activity"
+ options={
+ Enum.map(
+ @categories,
+ &{Catalog.category_path(&1, @current_scope.user.locale), &1.id}
+ )
+ }
+ />
+
+ {@selected_category.description}
+
+
+
+
Activity details
+
+
+ {field_label(field, @current_scope.user.locale)}
+
+ Choose…
+
+ {option_label(option, @current_scope.user.locale)}
+
+
+
+ Choose…
+
+ Yes
+
+
+ No
+
+
+
+
+
+ {message}
+
+
+
+ <.input field={@form[:title]} label="Short title" placeholder="Coffee and conversation" />
+ <.input
+ field={@form[:description]}
+ type="textarea"
+ label="Plan and expectations"
+ placeholder="Describe the public plan, approximate duration, and who might enjoy it."
+ />
+
+ <.input field={@form[:starts_at]} type="datetime-local" label="Starts at (UTC)" />
+ <.input
+ field={@form[:join_deadline]}
+ type="datetime-local"
+ label="Join requests close (UTC)"
+ />
+
+ <.input field={@form[:capacity]} type="number" min="2" label="Total group capacity" />
+ <.input
+ field={@form[:location_label]}
+ label="Approximate public meeting area"
+ placeholder="City centre, near the main entrance"
+ />
+ <.input
+ field={@form[:location_visibility]}
+ type="select"
+ label="Public map visibility"
+ options={[
+ {"Approximate area", "approximate_public"},
+ {"Hidden", "hidden"}
+ ]}
+ />
+
+
+ Use my current foreground location
+
+
+ Exact coordinates are shown only to participants you approve.
+
+
+ <.input
+ field={@form[:latitude]}
+ id="activity-latitude"
+ type="number"
+ step="any"
+ label="Latitude"
+ />
+ <.input
+ field={@form[:longitude]}
+ id="activity-longitude"
+ type="number"
+ step="any"
+ label="Longitude"
+ />
+
+
+
+
+ I will approve participants individually, keep sensitive details in the approved group, and use an appropriate public first meeting point.
+
+
+ <.button class="btn btn-info btn-lg w-full" phx-disable-with="Publishing…">
+ Publish activity
+
+
+
+ """
+ end
+end
diff --git a/lib/who_need_help_web/live/activity_live/show.ex b/lib/who_need_help_web/live/activity_live/show.ex
new file mode 100644
index 0000000..5344477
--- /dev/null
+++ b/lib/who_need_help_web/live/activity_live/show.ex
@@ -0,0 +1,359 @@
+defmodule WhoNeedHelpWeb.ActivityLive.Show do
+ use WhoNeedHelpWeb, :live_view
+
+ alias WhoNeedHelp.Activities
+
+ @impl true
+ def mount(%{"id" => id}, _session, socket) do
+ case Activities.get_activity(socket.assigns.current_scope, id) do
+ {:ok, activity} ->
+ if connected?(socket), do: Activities.subscribe_activity(activity.id)
+ {:ok, load(socket, activity)}
+
+ {:error, _reason} ->
+ {:ok,
+ socket
+ |> put_flash(:error, "Activity is unavailable.")
+ |> push_navigate(to: ~p"/activities")}
+ end
+ end
+
+ @impl true
+ def handle_info({event, _payload}, socket)
+ when event in [
+ :activity_updated,
+ :join_requested,
+ :participant_approved,
+ :participant_declined,
+ :participant_left,
+ :activity_message
+ ] do
+ {:noreply, reload(socket)}
+ end
+
+ @impl true
+ def handle_event("join", _params, socket) do
+ respond(
+ socket,
+ Activities.request_to_join(socket.assigns.current_scope, socket.assigns.activity.id)
+ )
+ end
+
+ def handle_event("approve", %{"id" => id}, socket) do
+ respond(socket, Activities.approve_participant(socket.assigns.current_scope, id))
+ end
+
+ def handle_event("decline", %{"id" => id}, socket) do
+ respond(socket, Activities.decline_participant(socket.assigns.current_scope, id))
+ end
+
+ def handle_event("leave", _params, socket) do
+ respond(
+ socket,
+ Activities.leave_activity(socket.assigns.current_scope, socket.assigns.activity.id)
+ )
+ end
+
+ def handle_event("cancel", _params, socket) do
+ respond(
+ socket,
+ Activities.cancel_activity(socket.assigns.current_scope, socket.assigns.activity.id)
+ )
+ end
+
+ def handle_event("complete", _params, socket) do
+ respond(
+ socket,
+ Activities.complete_activity(socket.assigns.current_scope, socket.assigns.activity.id)
+ )
+ end
+
+ def handle_event("send-message", %{"activity_message" => params}, socket) do
+ case Activities.send_message(
+ socket.assigns.current_scope,
+ socket.assigns.activity.id,
+ params
+ ) do
+ {:ok, _message} ->
+ {:noreply, reload(socket)}
+
+ {:error, reason} ->
+ {:noreply, put_flash(socket, :error, error_message(reason))}
+ end
+ end
+
+ defp respond(socket, {:ok, _value}), do: {:noreply, reload(socket)}
+
+ defp respond(socket, {:error, reason}) do
+ {:noreply, put_flash(socket, :error, error_message(reason))}
+ end
+
+ defp reload(socket) do
+ case Activities.get_activity(socket.assigns.current_scope, socket.assigns.activity.id) do
+ {:ok, activity} ->
+ load(socket, activity)
+
+ {:error, _} ->
+ socket
+ |> put_flash(:error, "Activity is unavailable.")
+ |> push_navigate(to: ~p"/activities")
+ end
+ end
+
+ defp load(socket, activity) do
+ user = socket.assigns.current_scope.user
+ viewer_participant = Activities.participant_for(activity, user.id)
+ organizer? = activity.creator_id == user.id
+ approved? = Activities.approved_participant?(activity, user.id)
+ coordinates = Activities.coordinates_for(socket.assigns.current_scope, activity)
+
+ markers =
+ case coordinates do
+ nil ->
+ []
+
+ coordinates ->
+ [
+ Map.merge(coordinates, %{
+ id: activity.id,
+ title: activity.title,
+ location: activity.location_label
+ })
+ ]
+ end
+
+ socket
+ |> assign(:page_title, activity.title)
+ |> assign(:activity, activity)
+ |> assign(:viewer_participant, viewer_participant)
+ |> assign(:organizer?, organizer?)
+ |> assign(:approved?, approved?)
+ |> assign(:coordinates, coordinates)
+ |> assign(:markers, Jason.encode!(markers))
+ |> assign(:message_form, to_form(%{"body" => ""}, as: :activity_message))
+ end
+
+ defp can_request_join?(activity, nil), do: activity.status == :open
+
+ defp can_request_join?(activity, participant) do
+ activity.status == :open and participant.status in [:declined, :left]
+ end
+
+ defp pending_participants(activity) do
+ Enum.filter(activity.participants, &(&1.status == :requested))
+ end
+
+ defp approved_participants(activity) do
+ Enum.filter(activity.participants, &(&1.status == :approved))
+ end
+
+ defp ordered_messages(activity), do: Enum.sort_by(activity.messages, & &1.inserted_at, DateTime)
+
+ defp error_message(:already_joined), do: "You already have a join request for this activity."
+ defp error_message(:capacity_reached), do: "The approved group has reached its capacity."
+ defp error_message(:join_closed), do: "Join requests are closed."
+ defp error_message(:blocked), do: "This action is unavailable."
+ defp error_message(:forbidden), do: "You are not allowed to do that."
+ defp error_message(:invalid_transition), do: "This activity state has already changed."
+ defp error_message(:not_open), do: "This activity is no longer open."
+ defp error_message(:rate_limited), do: "Too many actions in the configured time window."
+ defp error_message(%Ecto.Changeset{}), do: "Please check the submitted message."
+ defp error_message(reason), do: "Could not complete the action: #{inspect(reason)}"
+
+ @impl true
+ def render(assigns) do
+ ~H"""
+
+ <.link navigate={~p"/activities"} class="btn btn-ghost btn-sm mb-4">
+ ← Back to activities
+
+
+
+
+
+
+
+ {WhoNeedHelp.Catalog.category_path(
+ @activity.category,
+ @current_scope.user.locale
+ )}
+
+ {@activity.status}
+
+ {length(approved_participants(@activity))}/{@activity.capacity} approved
+
+
+ {@activity.title}
+ {@activity.description}
+
+
+
+
Starts
+
+ {Calendar.strftime(@activity.starts_at, "%d %b %Y, %H:%M UTC")}
+
+
+
+
Join requests close
+
+ {Calendar.strftime(@activity.join_deadline, "%d %b %Y, %H:%M UTC")}
+
+
+
+
Meeting area
+ {@activity.location_label}
+
+
+
Organizer
+ {@activity.creator.display_name || "Community member"}
+
+
+
+ 0} class="mt-5">
+
Plan details
+
+
+
{String.replace(key, "_", " ")}
+ {to_string(value)}
+
+
+
+
+
+ Approved group chat
+
+ Only the organizer and approved participants can read or send these messages.
+
+
+
+ No messages yet.
+
+
+
+ {message.sender.display_name || "Participant"}
+
+ {message.body}
+
+
+
+
+
+
+
+
Location privacy
+
+ <%= if @approved? do %>
+ You are approved, so the map can show the exact meeting coordinates.
+ <% else %>
+ The public map is approximate or hidden. Exact coordinates appear only after approval.
+ <% end %>
+
+
+
+ Request to join
+
+
+
Approval pending
+
+ The organizer has not approved your request yet.
+
+
+
+ Leave activity
+
+
+ Organizer controls
+
+
+ {participant.user.display_name || "Community member"}
+
+
+ Approve
+
+
+ Decline
+
+
+
+
+ No pending join requests.
+
+
+
+ Mark completed
+
+
+ Cancel activity
+
+
+
+
+
+ Approved participants
+
+
+ {participant.user.display_name || "Community member"}
+
+ organizer
+
+
+
+
+
+
+ """
+ end
+end
diff --git a/lib/who_need_help_web/live/category_proposal_live.ex b/lib/who_need_help_web/live/category_proposal_live.ex
index 22497ea..1d0cd94 100644
--- a/lib/who_need_help_web/live/category_proposal_live.ex
+++ b/lib/who_need_help_web/live/category_proposal_live.ex
@@ -43,7 +43,7 @@ defmodule WhoNeedHelpWeb.CategoryProposalLive do
socket
|> assign(:page_title, "Category proposals")
|> assign(:proposals, Catalog.list_proposals())
- |> assign(:categories, Catalog.list_categories())
+ |> assign(:categories, Catalog.list_all_categories())
|> assign(:form, to_form(Catalog.change_proposal(%CategoryProposal{})))
end
@@ -64,6 +64,12 @@ defmodule WhoNeedHelpWeb.CategoryProposalLive do
label="Proposed category"
placeholder="Bicycle puncture"
/>
+ <.input
+ field={@form[:mode]}
+ type="select"
+ label="Mode"
+ options={[{"Urgent help", "help"}, {"Social activity", "activity"}]}
+ />
<.input
field={@form[:parent_id]}
type="select"
@@ -94,6 +100,7 @@ defmodule WhoNeedHelpWeb.CategoryProposalLive do
{proposal.proposed_name}
+
{proposal.mode}
{proposal.reason}
by {proposal.proposer.display_name}
diff --git a/lib/who_need_help_web/live/moderation_live.ex b/lib/who_need_help_web/live/moderation_live.ex
index 5c9982e..7fd3121 100644
--- a/lib/who_need_help_web/live/moderation_live.ex
+++ b/lib/who_need_help_web/live/moderation_live.ex
@@ -130,7 +130,7 @@ defmodule WhoNeedHelpWeb.ModerationLive do
|> assign(:signals, Trust.list_abuse_signals(socket.assigns.current_scope))
|> assign(:proposals, Catalog.list_proposals_for_moderation(socket.assigns.current_scope))
|> assign(:users, Accounts.list_users_for_moderation(socket.assigns.current_scope))
- |> assign(:categories, Catalog.list_categories())
+ |> assign(:categories, Catalog.list_all_categories())
end
defp error_message(:forbidden), do: "Moderator access is required."
diff --git a/lib/who_need_help_web/router.ex b/lib/who_need_help_web/router.ex
index 921138a..76da437 100644
--- a/lib/who_need_help_web/router.ex
+++ b/lib/who_need_help_web/router.ex
@@ -95,6 +95,9 @@ defmodule WhoNeedHelpWeb.Router do
live "/requests", RequestLive.Index, :index
live "/requests/new", RequestLive.New, :new
live "/requests/:id", RequestLive.Show, :show
+ live "/activities", ActivityLive.Index, :index
+ live "/activities/new", ActivityLive.New, :new
+ live "/activities/:id", ActivityLive.Show, :show
live "/categories/proposals", CategoryProposalLive, :index
live "/profile", ProfileLive, :edit
live "/leaderboard", LeaderboardLive, :index
diff --git a/priv/repo/migrations/20260718172944_create_activity_mode.exs b/priv/repo/migrations/20260718172944_create_activity_mode.exs
new file mode 100644
index 0000000..aa93942
--- /dev/null
+++ b/priv/repo/migrations/20260718172944_create_activity_mode.exs
@@ -0,0 +1,84 @@
+defmodule WhoNeedHelp.Repo.Migrations.CreateActivityMode do
+ use Ecto.Migration
+
+ def change do
+ alter table(:categories) do
+ add :mode, :string, null: false, default: "help"
+ end
+
+ create index(:categories, [:mode, :active, :sort_order])
+
+ alter table(:category_proposals) do
+ add :mode, :string, null: false, default: "help"
+ end
+
+ create index(:category_proposals, [:mode, :status])
+
+ create table(:activities, primary_key: false) do
+ add :id, :binary_id, primary_key: true
+ add :title, :string, null: false
+ add :description, :text, null: false
+ add :structured_data, :map, null: false, default: %{}
+ add :location_label, :string, null: false
+ add :location, :geometry, null: false
+ add :location_visibility, :string, null: false, default: "approximate_public"
+ add :status, :string, null: false, default: "open"
+ add :starts_at, :utc_datetime, null: false
+ add :join_deadline, :utc_datetime, null: false
+ add :capacity, :integer, null: false
+ add :cancelled_at, :utc_datetime
+ add :completed_at, :utc_datetime
+ add :hidden_at, :utc_datetime
+ add :hidden_reason, :text
+ add :creator_id, references(:users, type: :binary_id, on_delete: :restrict), null: false
+
+ add :category_id, references(:categories, type: :binary_id, on_delete: :restrict),
+ null: false
+
+ timestamps(type: :utc_datetime)
+ end
+
+ create index(:activities, [:creator_id, :starts_at])
+ create index(:activities, [:category_id, :status, :starts_at])
+ create index(:activities, [:status, :hidden_at, :join_deadline])
+ create index(:activities, [:location], using: :gist)
+ create constraint(:activities, :activity_capacity_at_least_two, check: "capacity >= 2")
+
+ create constraint(:activities, :activity_join_before_start,
+ check: "join_deadline <= starts_at"
+ )
+
+ create table(:activity_participants, primary_key: false) do
+ add :id, :binary_id, primary_key: true
+ add :role, :string, null: false, default: "participant"
+ add :status, :string, null: false, default: "requested"
+ add :reviewed_at, :utc_datetime
+ add :left_at, :utc_datetime
+
+ add :activity_id, references(:activities, type: :binary_id, on_delete: :delete_all),
+ null: false
+
+ add :user_id, references(:users, type: :binary_id, on_delete: :restrict), null: false
+
+ timestamps(type: :utc_datetime)
+ end
+
+ create unique_index(:activity_participants, [:activity_id, :user_id])
+ create index(:activity_participants, [:user_id, :status])
+ create index(:activity_participants, [:activity_id, :status])
+
+ create table(:activity_messages, primary_key: false) do
+ add :id, :binary_id, primary_key: true
+ add :body, :text, null: false
+
+ add :activity_id, references(:activities, type: :binary_id, on_delete: :delete_all),
+ null: false
+
+ add :sender_id, references(:users, type: :binary_id, on_delete: :restrict), null: false
+
+ timestamps(type: :utc_datetime)
+ end
+
+ create index(:activity_messages, [:activity_id, :inserted_at])
+ end
+end
diff --git a/test/who_need_help/activities_test.exs b/test/who_need_help/activities_test.exs
new file mode 100644
index 0000000..067c84e
--- /dev/null
+++ b/test/who_need_help/activities_test.exs
@@ -0,0 +1,158 @@
+defmodule WhoNeedHelp.ActivitiesTest do
+ use WhoNeedHelp.DataCase, async: false
+
+ import WhoNeedHelp.AccountsFixtures
+
+ alias WhoNeedHelp.{Activities, Catalog, Trust}
+ alias WhoNeedHelp.Activities.Activity
+
+ setup do
+ Catalog.seed_defaults()
+
+ organizer = user_fixture(display_name: "Organizer")
+ participant = user_fixture(display_name: "Participant")
+ outsider = user_fixture(display_name: "Outsider")
+
+ coffee =
+ Catalog.list_categories(:activity)
+ |> Enum.find(&(&1.slug == "coffee-meetup"))
+
+ attrs = %{
+ "title" => "Coffee and conversation",
+ "description" => "Meet at a public café for conversation and tea.",
+ "structured_data" => %{"setting" => "cafe"},
+ "location_label" => "Central square",
+ "latitude" => "50.4501",
+ "longitude" => "30.5234",
+ "location_visibility" => "approximate_public",
+ "starts_at" => DateTime.utc_now(:second) |> DateTime.add(2, :hour),
+ "join_deadline" => DateTime.utc_now(:second) |> DateTime.add(1, :hour),
+ "capacity" => 2,
+ "category_id" => coffee.id
+ }
+
+ {:ok,
+ organizer: organizer,
+ participant: participant,
+ outsider: outsider,
+ organizer_scope: user_scope_fixture(organizer),
+ participant_scope: user_scope_fixture(participant),
+ outsider_scope: user_scope_fixture(outsider),
+ coffee: coffee,
+ attrs: attrs}
+ end
+
+ test "organizer approves a participant and the approved group can chat", context do
+ assert {:ok, activity} =
+ Activities.create_activity(context.organizer_scope, context.attrs)
+
+ assert [%{role: :organizer, status: :approved}] = activity.participants
+
+ assert Activity.public_coordinates(activity) == %{
+ latitude: 50.45,
+ longitude: 30.52,
+ exact: false
+ }
+
+ assert Activities.coordinates_for(context.outsider_scope, activity).exact == false
+ assert Activities.coordinates_for(context.organizer_scope, activity).exact == true
+
+ assert {:error, :forbidden} =
+ Activities.send_message(context.outsider_scope, activity.id, %{"body" => "Hello"})
+
+ assert {:ok, request} =
+ Activities.request_to_join(context.participant_scope, activity.id)
+
+ assert request.status == :requested
+
+ assert {:ok, approved} =
+ Activities.approve_participant(context.organizer_scope, request.id)
+
+ assert approved.status == :approved
+
+ assert {:ok, message} =
+ Activities.send_message(context.participant_scope, activity.id, %{
+ "body" => "See you at the café."
+ })
+
+ assert message.body == "See you at the café."
+
+ assert {:ok, loaded} = Activities.get_activity(context.participant_scope, activity.id)
+ assert [%{body: "See you at the café."}] = loaded.messages
+ assert Activities.coordinates_for(context.participant_scope, loaded).exact == true
+
+ assert {:error, :capacity_reached} =
+ Activities.request_to_join(context.outsider_scope, activity.id)
+ end
+
+ test "unapproved viewers receive no private chat or pending participant data", context do
+ {:ok, activity} = Activities.create_activity(context.organizer_scope, context.attrs)
+ {:ok, request} = Activities.request_to_join(context.participant_scope, activity.id)
+
+ assert {:ok, public_activity} =
+ Activities.get_activity(context.outsider_scope, activity.id)
+
+ assert public_activity.messages == []
+ assert Enum.all?(public_activity.participants, &(&1.status == :approved))
+ refute Enum.any?(public_activity.participants, &(&1.id == request.id))
+
+ assert {:ok, requester_view} =
+ Activities.get_activity(context.participant_scope, activity.id)
+
+ assert requester_view.messages == []
+ assert Enum.any?(requester_view.participants, &(&1.id == request.id))
+ end
+
+ test "activity completion never changes urgent-help reputation", context do
+ {:ok, activity} = Activities.create_activity(context.organizer_scope, context.attrs)
+ {:ok, request} = Activities.request_to_join(context.participant_scope, activity.id)
+ {:ok, _approved} = Activities.approve_participant(context.organizer_scope, request.id)
+ assert {:ok, completed} = Activities.complete_activity(context.organizer_scope, activity.id)
+ assert completed.status == :completed
+
+ assert Trust.reputation(context.organizer.id).completed == 0
+ assert Trust.reputation(context.participant.id).completed == 0
+ assert {:error, :not_found} = Activities.get_activity(context.outsider_scope, activity.id)
+ assert {:ok, _activity} = Activities.get_activity(context.participant_scope, activity.id)
+ end
+
+ test "activity category and structured fields are enforced", context do
+ hiking =
+ Catalog.list_categories(:activity)
+ |> Enum.find(&(&1.slug == "hiking-group"))
+
+ invalid =
+ context.attrs
+ |> Map.put("category_id", hiking.id)
+ |> Map.put("structured_data", %{
+ "difficulty" => "easy",
+ "route_plan" => "Marked public trail"
+ })
+
+ assert {:error, changeset} =
+ Activities.create_activity(context.organizer_scope, invalid)
+
+ assert "safety_plan_confirmed is required" in errors_on(changeset).structured_data
+
+ help_category = Catalog.seed_defaults()
+
+ invalid =
+ context.attrs
+ |> Map.put("category_id", help_category.id)
+ |> Map.put("structured_data", %{"pickup_status" => "reserved"})
+
+ assert {:error, changeset} =
+ Activities.create_activity(context.organizer_scope, invalid)
+
+ assert "select an activity category" in errors_on(changeset).category_id
+ end
+
+ test "blocking prevents activity discovery and joining", context do
+ {:ok, activity} = Activities.create_activity(context.organizer_scope, context.attrs)
+ assert {:ok, _block} = Trust.block(context.organizer_scope, context.participant.id)
+ assert [] = Activities.list_open_activities(context.participant_scope)
+
+ assert {:error, :blocked} =
+ Activities.request_to_join(context.participant_scope, activity.id)
+ end
+end
diff --git a/test/who_need_help/mutual_aid_flow_test.exs b/test/who_need_help/mutual_aid_flow_test.exs
index d6ff808..e0299ef 100644
--- a/test/who_need_help/mutual_aid_flow_test.exs
+++ b/test/who_need_help/mutual_aid_flow_test.exs
@@ -138,6 +138,7 @@ defmodule WhoNeedHelp.MutualAidFlowTest do
assert proposal_export["proposal_id"] == proposal.id
assert proposal_export["proposed_name"] == "Bicycle repair"
+ assert proposal_export["mode"] == "help"
assert proposal_export["community_votes"] == 0
refute export =~ context.requester.email
@@ -186,7 +187,7 @@ defmodule WhoNeedHelp.MutualAidFlowTest do
assert context.category.id == Catalog.seed_defaults().id
assert first_ids == Catalog.list_categories() |> Map.new(&{&1.slug, &1.id})
- assert Repo.aggregate(WhoNeedHelp.Catalog.Category, :count) == 9
+ assert Repo.aggregate(WhoNeedHelp.Catalog.Category, :count) == 14
end
test "roadside structured data is enforced when creating a request", context do
diff --git a/test/who_need_help_web/live/mutual_aid_live_test.exs b/test/who_need_help_web/live/mutual_aid_live_test.exs
index b1faea2..987fb10 100644
--- a/test/who_need_help_web/live/mutual_aid_live_test.exs
+++ b/test/who_need_help_web/live/mutual_aid_live_test.exs
@@ -4,7 +4,7 @@ defmodule WhoNeedHelpWeb.MutualAidLiveTest do
import Phoenix.LiveViewTest
import WhoNeedHelp.AccountsFixtures
- alias WhoNeedHelp.{Catalog, Help, Messaging, Trust}
+ alias WhoNeedHelp.{Activities, Catalog, Help, Messaging, Trust}
alias WhoNeedHelp.Repo
setup :register_and_log_in_user
@@ -68,6 +68,87 @@ defmodule WhoNeedHelpWeb.MutualAidLiveTest do
)
end
+ test "activity form is category-driven and separate from urgent help", %{conn: conn} do
+ Catalog.seed_defaults()
+
+ hiking =
+ Catalog.list_categories(:activity)
+ |> Enum.find(&(&1.slug == "hiking-group"))
+
+ {:ok, view, html} = live(conn, ~p"/activities/new")
+ assert html =~ "Social activity — Hiking"
+ refute html =~ "Medicine pickup status"
+
+ html =
+ render_change(view, "validate", %{
+ "activity" => %{"category_id" => hiking.id}
+ })
+
+ assert html =~ "Route difficulty"
+ assert html =~ "activity[structured_data][route_plan]"
+ assert html =~ "activity[structured_data][safety_plan_confirmed]"
+ assert html =~ "approve participants individually"
+ end
+
+ test "organizer approves an activity participant and group chat updates live", %{
+ conn: organizer_conn,
+ scope: organizer_scope
+ } do
+ Catalog.seed_defaults()
+ participant = user_fixture(display_name: "Activity participant")
+ participant_conn = build_conn() |> log_in_user(participant)
+
+ coffee =
+ Catalog.list_categories(:activity)
+ |> Enum.find(&(&1.slug == "coffee-meetup"))
+
+ attrs = %{
+ "title" => "Public coffee meetup",
+ "description" => "Meet at a public café for tea and conversation.",
+ "structured_data" => %{"setting" => "cafe"},
+ "location_label" => "Central square",
+ "latitude" => "50.4501",
+ "longitude" => "30.5234",
+ "location_visibility" => "approximate_public",
+ "starts_at" => DateTime.utc_now(:second) |> DateTime.add(2, :hour),
+ "join_deadline" => DateTime.utc_now(:second) |> DateTime.add(1, :hour),
+ "capacity" => 3,
+ "category_id" => coffee.id
+ }
+
+ {:ok, activity} = Activities.create_activity(organizer_scope, attrs)
+ {:ok, organizer_view, _html} = live(organizer_conn, ~p"/activities/#{activity.id}")
+ {:ok, participant_view, html} = live(participant_conn, ~p"/activities/#{activity.id}")
+ assert html =~ "Request to join"
+ refute html =~ "Approved group chat"
+
+ participant_view
+ |> element("button[phx-click='join']")
+ |> render_click()
+
+ assert render(participant_view) =~ "Approval pending"
+ assert render(organizer_view) =~ "Activity participant"
+
+ organizer_view
+ |> element("button[phx-click='approve']")
+ |> render_click()
+
+ assert render(participant_view) =~ "Approved group chat"
+
+ html =
+ participant_view
+ |> form("form[phx-submit='send-message']", %{
+ "activity_message" => %{"body" => "I will be there."}
+ })
+ |> render_submit()
+
+ assert html =~ "I will be there."
+ assert render(organizer_view) =~ "I will be there."
+
+ stop_live_view(organizer_view)
+ stop_live_view(participant_view)
+ end
+
test "views opened before matching subscribe to the private chat after assignment", %{
conn: requester_conn,
scope: requester_scope