Team Management UI

lib/plausible/application.ex

@@ -15,6 +15,7 @@ defmodule Plausible.Application do
 
     children =
       [
+        Plausible.PromEx,
         Plausible.Cache.Stats,
         Plausible.Repo,
         Plausible.ClickhouseRepo,
@@ -104,7 +105,6 @@ defmodule Plausible.Application do
         end,
         endpoint,
         {Oban, Application.get_env(:plausible, Oban)},
-        Plausible.PromEx,
         on_ee do
           help_scout_vault()
         end

lib/plausible/prom_ex.ex

@@ -3,23 +3,33 @@ defmodule Plausible.PromEx do
 
   alias PromEx.Plugins
 
+  @plugins [
+    Plugins.Application,
+    Plugins.Beam,
+    Plugins.PhoenixLiveView,
+    {Plugins.Phoenix, router: PlausibleWeb.Router, endpoint: PlausibleWeb.Endpoint},
+    {Plugins.Ecto,
+     repos: [
+       Plausible.Repo,
+       Plausible.ClickhouseRepo,
+       Plausible.IngestRepo,
+       Plausible.AsyncInsertRepo
+     ]},
+    Plausible.PromEx.Plugins.PlausibleMetrics
+  ]
+
   @impl true
-  def plugins do
-    [
-      Plugins.Application,
-      Plugins.Beam,
-      Plugins.PhoenixLiveView,
-      {Plugins.Phoenix, router: PlausibleWeb.Router, endpoint: PlausibleWeb.Endpoint},
-      {Plugins.Ecto,
-       repos: [
-         Plausible.Repo,
-         Plausible.ClickhouseRepo,
-         Plausible.IngestRepo,
-         Plausible.AsyncInsertRepo
-       ]},
-      Plugins.Oban,
-      Plausible.PromEx.Plugins.PlausibleMetrics
-    ]
+  if Mix.env() in [:test, :ce_test] do
+    # PromEx tries to query Oban's DB tables in order to retrieve metrics.
+    # During tests, however, this is pointless as Oban is in manual mode,
+    # and that leads to connection ownership clashes.
+    def plugins do
+      @plugins
+    end
+  else
+    def plugins do
+      [Plugins.Oban | @plugins]
+    end
   end
 
   @impl true

lib/plausible/teams.ex

@@ -273,39 +273,6 @@ defmodule Plausible.Teams do
     )
   end
 
-  def setup_team(team, candidates) do
-    inviter = Repo.preload(team, :owner).owner
-
-    setup_team_fn = fn {{email, _name}, role} ->
-      case Teams.Invitations.InviteToTeam.invite(team, inviter, email, role, send_email?: false) do
-        {:ok, invitation} -> invitation
-        {:error, error} -> Repo.rollback(error)
-      end
-    end
-
-    result =
-      Repo.transaction(fn ->
-        team
-        |> Teams.Team.setup_changeset()
-        |> Repo.update!()
-
-        Enum.map(candidates, setup_team_fn)
-      end)
-
-    case result do
-      {:ok, invitations} ->
-        Enum.each(invitations, fn invitation ->
-          invitee = Auth.find_user_by(email: invitation.email)
-          Teams.Invitations.InviteToTeam.send_invitation_email(invitation, invitee)
-        end)
-
-        {:ok, invitations}
-
-      {:error, {:over_limit, _}} = error ->
-        error
-    end
-  end
-
   defp create_my_team(user) do
     team =
       "My Team"

lib/plausible/teams/invitations.ex

@@ -35,7 +35,16 @@ defmodule Plausible.Teams.Invitations do
     end
   end
 
-  def find_team_invitations(user) do
+  def all(%Teams.Team{} = team) do
+    Repo.all(
+      from ti in Teams.Invitation,
+        inner_join: inviter in assoc(ti, :inviter),
+        where: ti.team_id == ^team.id,
+        preload: [inviter: inviter]
+    )
+  end
+
+  def all(%Plausible.Auth.User{} = user) do
     Repo.all(
       from ti in Teams.Invitation,
         inner_join: inviter in assoc(ti, :inviter),

lib/plausible/teams/management/layout.ex

@@ -0,0 +1,178 @@
+defmodule Plausible.Teams.Management.Layout do
+  @moduledoc """
+  Abstraction for team membership(s) layout - provides a high level CRUD for
+  setting up team memberships, including invitations. Persisting the layout,
+  effectively takes care of delegating the operations to specialized services
+  and sending out e-mail notifications on success, if need be.
+  To be used in UIs allowing team memberships adjustments.
+  """
+  alias Plausible.Teams
+  alias Plausible.Teams.Management.Layout.Entry
+  alias Plausible.Repo
+  alias Plausible.Auth.User
+
+  @type t() :: %{String.t() => Entry.t()}
+
+  @spec init(Teams.Team.t()) :: t()
+  def init(%Teams.Team{} = team) do
+    invitations_sent = Teams.Invitations.all(team)
+    all_members = Teams.Memberships.all(team)
+    build_by_email(invitations_sent ++ all_members)
+  end
+
+  @spec build_by_email([Teams.Invitation.t() | Teams.Membership.t()]) ::
+          t()
+  def build_by_email(entities) do
+    Enum.reduce(entities, %{}, fn
+      %Teams.Invitation{} = invitation, acc ->
+        Map.put(acc, invitation.email, Entry.new(invitation))
+
+      %Teams.Membership{} = membership, acc ->
+        Map.put(
+          acc,
+          membership.user.email,
+          Entry.new(membership)
+        )
+    end)
+  end
+
+  @spec active_count(t()) :: non_neg_integer()
+  def active_count(layout) do
+    Enum.count(layout, fn {_, entry} -> entry.queued_op != :delete end)
+  end
+
+  @spec owners_count(t()) :: non_neg_integer()
+  def owners_count(layout) do
+    Enum.count(layout, fn {_, entry} -> entry.queued_op != :delete and entry.role == :owner end)
+  end
+
+  @spec has_guests?(t()) :: boolean()
+  def has_guests?(layout) do
+    not is_nil(
+      Enum.find(
+        layout,
+        fn
+          {_, entry} -> entry.role == :guest and entry.queued_op != :delete
+        end
+      )
+    )
+  end
+
+  @spec update_role(t(), String.t(), atom()) :: t()
+  def update_role(layout, email, role) do
+    entry = Map.fetch!(layout, email)
+    Map.put(layout, email, Entry.patch(entry, role: role, queued_op: :update))
+  end
+
+  @spec schedule_send(t(), String.t(), atom(), Keyword.t()) :: t()
+  def schedule_send(layout, email, role, entry_attrs \\ []) do
+    invitation = %Teams.Invitation{email: email, role: role}
+    Map.put(layout, email, Entry.new(invitation, Keyword.merge(entry_attrs, queued_op: :send)))
+  end
+
+  @spec schedule_delete(t(), String.t()) :: t()
+  def schedule_delete(layout, email) do
+    entry = Map.fetch!(layout, email)
+    Map.put(layout, email, Entry.patch(entry, queued_op: :delete))
+  end
+
+  @spec verify_removable(t(), String.t()) :: :ok | {:error, String.t()}
+  def verify_removable(layout, email) do
+    ensure_at_least_one_owner(layout, email)
+  end
+
+  @spec removable?(t(), String.t()) :: boolean()
+  def removable?(layout, email) do
+    verify_removable(layout, email) == :ok
+  end
+
+  @spec sorted_for_display(t()) :: [{String.t(), Entry.t()}]
+  def sorted_for_display(layout) do
+    layout
+    |> Enum.reject(fn {_, entry} -> entry.queued_op == :delete end)
+    |> Enum.sort_by(fn {email, entry} ->
+      primary_criterion =
+        case entry do
+          %{role: :guest, type: :invitation_pending} -> 10
+          %{role: :guest, type: :invitation_sent} -> 11
+          %{role: :guest, type: :membership} -> 12
+          %{type: :invitation_pending} -> 0
+          %{type: :invitation_sent} -> 1
+          %{type: :membership} -> 2
+        end
+
+      secondary_criterion = entry.name
+      tertiary_criterion = email
+      {primary_criterion, secondary_criterion, tertiary_criterion}
+    end)
+  end
+
+  @spec persist(t(), %{current_user: User.t(), my_team: Teams.Team.t()}) ::
+          {:ok, integer()} | {:error, any()}
+  def persist(layout, context) do
+    result =
+      Repo.transaction(fn ->
+        if not context.my_team.setup_complete do
+          context.my_team
+          |> Teams.Team.setup_changeset()
+          |> Repo.update!()
+        end
+
+        layout
+        |> sorted_for_persistence()
+        |> Enum.reduce([], fn {_, entry}, acc ->
+          persist_entry(entry, context, acc)
+        end)
+      end)
+
+    case result do
+      {:ok, persisted} ->
+        persisted
+        |> Enum.each(fn
+          {%Entry{type: :invitation_pending}, invitation} ->
+            invitee = Plausible.Auth.find_user_by(email: invitation.email)
+            Teams.Invitations.InviteToTeam.send_invitation_email(invitation, invitee)
+
+          {%Entry{type: :membership, queued_op: :delete}, team_membership} ->
+            Teams.Memberships.Remove.send_team_member_removed_email(team_membership)
+
+          _ ->
+            :noop
+        end)
+
+        {:ok, length(persisted)}
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  defp sorted_for_persistence(layout) do
+    # sort by deletions first, so team member limits are triggered accurately
+    Enum.sort_by(layout, fn {_email, entry} ->
+      case entry.queued_op do
+        :delete -> 0
+        _ -> 1
+      end
+    end)
+  end
+
+  defp ensure_at_least_one_owner(layout, email) do
+    if Enum.find(layout, fn {_email, entry} ->
+         entry.email != email and
+           entry.role == :owner and
+           entry.type == :membership and
+           entry.queued_op != :delete
+       end),
+       do: :ok,
+       else: {:error, "The team has to have at least one owner"}
+  end
+
+  def persist_entry(entry, context, acc) do
+    case Entry.persist(entry, context) do
+      {:ok, :ignore} -> acc
+      {:ok, persist_result} -> [{entry, persist_result} | acc]
+      {:error, error} -> Repo.rollback(error)
+    end
+  end
+end