Refactoring of Actors context

lib/mobilizon/actors/member.ex

@@ -1,100 +1,59 @@
-import EctoEnum
-
-defenum(Mobilizon.Actors.MemberRoleEnum, :member_role_type, [
-  :not_approved,
-  :member,
-  :moderator,
-  :administrator,
-  :creator
-])
-
 defmodule Mobilizon.Actors.Member do
   @moduledoc """
-  Represents the membership of an actor to a group
+  Represents the membership of an actor to a group.
   """
 
   use Ecto.Schema
 
   import Ecto.Changeset
-  import Ecto.Query
 
-  alias Mobilizon.Actors.{Actor, Member}
-  alias Mobilizon.Storage.{Page, Repo}
+  alias Mobilizon.Actors.{Actor, Member, MemberRole}
+  
+  @type t :: %__MODULE__{
+          role: MemberRole.t(),
+          parent: Actor.t(),
+          actor: Actor.t()
+        }
+
+  @required_attrs [:parent_id, :actor_id]
+  @optional_attrs [:role]
+  @attrs @required_attrs ++ @optional_attrs
 
   schema "members" do
-    field(:role, Mobilizon.Actors.MemberRoleEnum, default: :member)
+    field(:role, MemberRole, default: :member)
+
     belongs_to(:parent, Actor)
     belongs_to(:actor, Actor)
 
     timestamps()
   end
 
-  @doc false
-  def changeset(%Member{} = member, attrs) do
-    member
-    |> cast(attrs, [:role, :parent_id, :actor_id])
-    |> validate_required([:parent_id, :actor_id])
-    |> unique_constraint(:parent_id, name: :members_actor_parent_unique_index)
-  end
-
   @doc """
-  Gets a single member of an actor (for example a group)
+  Gets the default member role depending on the actor openness.
   """
-  def get_member(actor_id, parent_id) do
-    case Repo.get_by(Member, actor_id: actor_id, parent_id: parent_id) do
-      nil -> {:error, :member_not_found}
-      member -> {:ok, member}
-    end
-  end
+  @spec get_default_member_role(Actor.t()) :: atom
+  def get_default_member_role(%Actor{openness: :open}), do: :member
+  def get_default_member_role(%Actor{}), do: :not_approved
 
   @doc """
-  Gets a single member of an actor (for example a group)
+  Checks whether the actor can be joined to the group.
   """
   def can_be_joined(%Actor{type: :Group, openness: :invite_only}), do: false
   def can_be_joined(%Actor{type: :Group}), do: true
 
   @doc """
-  Returns the list of administrator members for a group.
-  """
-  def list_administrator_members_for_group(id, page \\ nil, limit \\ nil) do
-    Repo.all(
-      from(
-        m in Member,
-        where: m.parent_id == ^id and (m.role == ^:creator or m.role == ^:administrator),
-        preload: [:actor]
-      )
-      |> Page.paginate(page, limit)
-    )
-  end
-
-  @doc """
-  Get all group ids where the actor_id is the last administrator
-  """
-  def list_group_id_where_last_administrator(actor_id) do
-    in_query =
-      from(
-        m in Member,
-        where: m.actor_id == ^actor_id and (m.role == ^:creator or m.role == ^:administrator),
-        select: m.parent_id
-      )
-
-    Repo.all(
-      from(
-        m in Member,
-        where: m.role == ^:creator or m.role == ^:administrator,
-        join: m2 in subquery(in_query),
-        on: m.parent_id == m2.parent_id,
-        group_by: m.parent_id,
-        select: m.parent_id,
-        having: count(m.actor_id) == 1
-      )
-    )
-  end
-
-  @doc """
-  Returns true if the member is an administrator (admin or creator) of the group
+  Checks whether the member is an administrator (admin or creator) of the group.
   """
   def is_administrator(%Member{role: :administrator}), do: {:is_admin, true}
   def is_administrator(%Member{role: :creator}), do: {:is_admin, true}
   def is_administrator(%Member{}), do: {:is_admin, false}
+
+  @doc false
+  @spec changeset(t | Ecto.Changeset.t(), map) :: Ecto.Changeset.t()
+  def changeset(member, attrs) do
+    member
+    |> cast(attrs, @attrs)
+    |> validate_required(@required_attrs)
+    |> unique_constraint(:parent_id, name: :members_actor_parent_unique_index)
+  end
 end