feat: enhance chat functionality and thread management

- Introduced a new `MessageCreated` struct to encapsulate message and participant data for broadcasting.
- Refactored the `broadcast` function to utilize the new struct for improved clarity.
- Added `ensure_participant` and `insert_message` private functions to streamline message handling.
- Implemented `get_or_create_bounty_thread` to manage thread creation for bounties.
- Updated `BountyLive` to integrate chat features, including message and participant management.
- Added `bounty_id` field to the `Thread` schema and created a migration for the database update.

Author: zcesur

lib/algora/chat/chat.ex

@@ -8,8 +8,13 @@ defmodule Algora.Chat do
   alias Algora.Chat.Thread
   alias Algora.Repo
 
-  def broadcast(message) do
-    Phoenix.PubSub.broadcast(Algora.PubSub, "chat:thread:#{message.thread_id}", message)
+  defmodule MessageCreated do
+    @moduledoc false
+    defstruct message: nil, participant: nil
+  end
+
+  def broadcast(%MessageCreated{} = event) do
+    Phoenix.PubSub.broadcast(Algora.PubSub, "chat:thread:#{event.message.thread_id}", event)
   end
 
   def subscribe(thread_id) do
@@ -23,7 +28,6 @@ defmodule Algora.Chat do
         |> Thread.changeset(%{title: "#{User.handle(user_1)} <> #{User.handle(user_2)}"})
         |> Repo.insert()
 
-      # Add participants
       for user <- [user_1, user_2] do
         %Participant{}
         |> Participant.changeset(%{
@@ -46,7 +50,7 @@ defmodule Algora.Chat do
         |> Repo.insert()
 
       participants = Enum.uniq_by([user | admins], & &1.id)
-      # Add participants
+
       for u <- participants do
         %Participant{}
         |> Participant.changeset(%{
@@ -61,20 +65,41 @@ defmodule Algora.Chat do
     end)
   end
 
+  defp ensure_participant(thread_id, user_id) do
+    case Repo.fetch_by(Participant, thread_id: thread_id, user_id: user_id) do
+      {:ok, participant} ->
+        {:ok, participant}
+
+      {:error, _} ->
+        %Participant{}
+        |> Participant.changeset(%{
+          thread_id: thread_id,
+          user_id: user_id,
+          last_read_at: DateTime.utc_now()
+        })
+        |> Repo.insert()
+    end
+  end
+
+  defp insert_message(thread_id, sender_id, content) do
+    %Message{}
+    |> Message.changeset(%{
+      thread_id: thread_id,
+      sender_id: sender_id,
+      content: content
+    })
+    |> Repo.insert()
+  end
+
   def send_message(thread_id, sender_id, content) do
-    case %Message{}
-         |> Message.changeset(%{
-           thread_id: thread_id,
-           sender_id: sender_id,
-           content: content
-         })
-         |> Repo.insert() do
-      {:ok, message} ->
-        message |> Repo.preload(:sender) |> broadcast()
-        {:ok, message}
-
-      {:error, changeset} ->
-        {:error, changeset}
+    with {:ok, participant} <- ensure_participant(thread_id, sender_id),
+         {:ok, message} <- insert_message(thread_id, sender_id, content) do
+      broadcast(%MessageCreated{
+        message: Repo.preload(message, :sender),
+        participant: Repo.preload(participant, :user)
+      })
+
+      {:ok, message}
     end
   end
 
@@ -107,6 +132,12 @@ defmodule Algora.Chat do
     |> Repo.all()
   end
 
+  def list_participants(thread_id) do
+    Participant
+    |> where(thread_id: ^thread_id)
+    |> Repo.all()
+  end
+
   def mark_as_read(thread_id, user_id) do
     Participant
     |> where(thread_id: ^thread_id, user_id: ^user_id)
@@ -145,4 +176,16 @@ defmodule Algora.Chat do
       thread -> {:ok, thread}
     end
   end
+
+  def get_or_create_bounty_thread(bounty) do
+    case Repo.fetch_by(Thread, bounty_id: bounty.id) do
+      {:ok, thread} ->
+        {:ok, thread}
+
+      {:error, _} ->
+        %Thread{}
+        |> Thread.changeset(%{title: "Contributor chat", bounty_id: bounty.id})
+        |> Repo.insert()
+    end
+  end
 end

lib/algora/chat/schemas/thread.ex

@@ -6,7 +6,7 @@ defmodule Algora.Chat.Thread do
 
   typed_schema "threads" do
     field :title, :string
-
+    field :bounty_id, :string
     has_many :messages, Algora.Chat.Message
     has_many :participants, Algora.Chat.Participant
     has_many :activities, {"thread_activities", Activity}, foreign_key: :assoc_id
@@ -16,8 +16,9 @@ defmodule Algora.Chat.Thread do
 
   def changeset(thread, attrs) do
     thread
-    |> cast(attrs, [:title])
+    |> cast(attrs, [:title, :bounty_id])
     |> validate_required([:title])
     |> generate_id()
+    |> unique_constraint(:bounty_id)
   end
 end

lib/algora_web/live/bounty_live.ex

@@ -8,6 +8,7 @@ defmodule AlgoraWeb.BountyLive do
   alias Algora.Bounties
   alias Algora.Bounties.Bounty
   alias Algora.Bounties.LineItem
+  alias Algora.Chat
   alias Algora.Repo
   alias Algora.Util
   alias Algora.Workspace
@@ -95,6 +96,14 @@ defmodule AlgoraWeb.BountyLive do
 
     exclusive_changeset = ExclusiveBountyForm.changeset(%ExclusiveBountyForm{}, %{})
 
+    {:ok, thread} = Chat.get_or_create_bounty_thread(bounty)
+    messages = thread.id |> Chat.list_messages() |> Repo.preload(:sender)
+    participants = thread.id |> Chat.list_participants() |> Repo.preload(:user)
+
+    if connected?(socket) do
+      Chat.subscribe(thread.id)
+    end
+
     {:ok,
      socket
      |> assign(:page_title, bounty.ticket.title)
@@ -107,7 +116,9 @@ defmodule AlgoraWeb.BountyLive do
      |> assign(:show_exclusive_modal, false)
      |> assign(:selected_context, nil)
      |> assign(:line_items, [])
-     |> assign(:messages, [])
+     |> assign(:thread, thread)
+     |> assign(:messages, messages)
+     |> assign(:participants, participants)
      |> assign(:reward_form, to_form(reward_changeset))
      |> assign(:exclusive_form, to_form(exclusive_changeset))
      |> assign_exclusives(bounty.shared_with)}
@@ -118,34 +129,76 @@ defmodule AlgoraWeb.BountyLive do
     {:noreply, socket}
   end
 
+  @impl true
   def handle_params(%{"context" => context_id}, _url, socket) do
     {:noreply, socket |> assign_selected_context(context_id) |> assign_line_items()}
   end
 
+  @impl true
   def handle_params(_params, _url, socket) do
     {:noreply, socket}
   end
 
+  @impl true
+  def handle_info(%Chat.MessageCreated{message: message, participant: participant}, socket) do
+    socket =
+      if message.id in Enum.map(socket.assigns.messages, & &1.id) do
+        socket
+      else
+        Phoenix.Component.update(socket, :messages, &(&1 ++ [message]))
+      end
+
+    socket =
+      if participant.id in Enum.map(socket.assigns.participants, & &1.id) do
+        socket
+      else
+        Phoenix.Component.update(socket, :participants, &(&1 ++ [participant]))
+      end
+
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_event("send_message", %{"message" => content}, socket) do
+    {:ok, message} =
+      Chat.send_message(
+        socket.assigns.thread.id,
+        socket.assigns.current_user.id,
+        content
+      )
+
+    message = Repo.preload(message, :sender)
+
+    {:noreply,
+     socket
+     |> update(:messages, &(&1 ++ [message]))
+     |> push_event("clear-input", %{selector: "#message-input"})}
+  end
+
   @impl true
   def handle_event("reward", _params, socket) do
     {:noreply, assign(socket, :show_reward_modal, true)}
   end
 
+  @impl true
   def handle_event("exclusive", _params, socket) do
     {:noreply, assign(socket, :show_exclusive_modal, true)}
   end
 
+  @impl true
   def handle_event("close_drawer", _params, socket) do
     {:noreply, close_drawers(socket)}
   end
 
+  @impl true
   def handle_event("validate_reward", %{"reward_bounty_form" => params}, socket) do
     {:noreply,
      socket
      |> assign(:reward_form, to_form(RewardBountyForm.changeset(%RewardBountyForm{}, params)))
      |> assign_line_items()}
   end
 
+  @impl true
   def handle_event("pay_with_stripe", %{"reward_bounty_form" => params}, socket) do
     changeset = RewardBountyForm.changeset(%RewardBountyForm{}, params)
 
@@ -165,13 +218,15 @@ defmodule AlgoraWeb.BountyLive do
     end
   end
 
+  @impl true
   def handle_event("validate_exclusive", %{"exclusive_bounty_form" => params}, socket) do
     {:noreply,
      socket
      |> assign(:exclusive_form, to_form(ExclusiveBountyForm.changeset(%ExclusiveBountyForm{}, params)))
      |> assign_line_items()}
   end
 
+  @impl true
   def handle_event("share_exclusive", %{"exclusive_bounty_form" => params}, socket) do
     changeset = ExclusiveBountyForm.changeset(%ExclusiveBountyForm{}, params)
     bounty = socket.assigns.bounty
@@ -420,11 +475,11 @@ defmodule AlgoraWeb.BountyLive do
               Contributor chat
             </h2>
             <div class="relative flex -space-x-2">
-              <%= for user <- @exclusives do %>
+              <%= for participant <- @participants do %>
                 <.avatar>
-                  <.avatar_image src={user.avatar_url} alt="Developer avatar" />
+                  <.avatar_image src={participant.user.avatar_url} alt="Developer avatar" />
                   <.avatar_fallback>
-                    {Algora.Util.initials(@bounty.owner.name)}
+                    {Algora.Util.initials(participant.user.name)}
                   </.avatar_fallback>
                 </.avatar>
               <% end %>

lib/algora_web/live/chat/thread_live.ex

@@ -38,7 +38,7 @@ defmodule AlgoraWeb.Chat.ThreadLive do
   end
 
   @impl true
-  def handle_info(%Message{} = message, socket) do
+  def handle_info(%{message: message}, socket) do
     if message.id in Enum.map(socket.assigns.messages, & &1.id) do
       {:noreply, socket}
     else

lib/algora_web/live/contract/view_live.ex

@@ -510,7 +510,7 @@ defmodule AlgoraWeb.Contract.ViewLive do
     end
   end
 
-  def handle_info(%Chat.Message{} = message, socket) do
+  def handle_info(%Chat.MessageCreated{message: message}, socket) do
     if message.id in Enum.map(socket.assigns.messages, & &1.id) do
       {:noreply, socket}
     else

priv/repo/migrations/20250401065753_add_bounty_id_to_threads.exs

@@ -0,0 +1,11 @@
+defmodule Algora.Repo.Migrations.AddBountyIdToThreads do
+  use Ecto.Migration
+
+  def change do
+    alter table(:threads) do
+      add :bounty_id, :string, null: true
+    end
+
+    create unique_index(:threads, [:bounty_id])
+  end
+end