[#1335] Refactored UserMute and UserBlock into UserRelationship, introduced EctoEnum.

7 files changed, 156 insertions, 192 deletions

diff --git a/lib/pleroma/ecto_enums.ex b/lib/pleroma/ecto_enums.ex
new file mode 100644
index 000000000..bad5ec523
--- /dev/null
+++ b/lib/pleroma/ecto_enums.ex
@@ -0,0 +1,7 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+import EctoEnum
+
+defenum(UserRelationshipTypeEnum, block: 1, mute: 2, reblog_mute: 3, notification_mute: 4)
diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
index d6bc02d04..4dd03c6c6 100644
--- a/lib/pleroma/user.ex
+++ b/lib/pleroma/user.ex
@@ -22,8 +22,7 @@ defmodule Pleroma.User do
   alias Pleroma.Repo
   alias Pleroma.RepoStreamer
   alias Pleroma.User
-  alias Pleroma.UserBlock
-  alias Pleroma.UserMute
+  alias Pleroma.UserRelationship
   alias Pleroma.Web
   alias Pleroma.Web.ActivityPub.ActivityPub
   alias Pleroma.Web.ActivityPub.Utils
@@ -78,7 +77,6 @@ defmodule Pleroma.User do
     field(:confirmation_token, :string, default: nil)
     field(:default_scope, :string, default: "public")
     field(:domain_blocks, {:array, :string}, default: [])
-    field(:mutes, {:array, :string}, default: [])
     field(:muted_reblogs, {:array, :string}, default: [])
     field(:muted_notifications, {:array, :string}, default: [])
     field(:subscribers, {:array, :string}, default: [])
@@ -121,20 +119,41 @@ defmodule Pleroma.User do
     has_many(:registrations, Registration)
     has_many(:deliveries, Delivery)
 
-    has_many(:blocker_blocks, UserBlock, foreign_key: :blocker_id)
-    has_many(:blockee_blocks, UserBlock, foreign_key: :blockee_id)
-    has_many(:blocked_users, through: [:blocker_blocks, :blockee])
-    has_many(:blocker_users, through: [:blockee_blocks, :blocker])
+    has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
+    has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
+
+    has_many(:blocker_blocks, UserRelationship,
+      foreign_key: :source_id,
+      where: [relationship_type: :block]
+    )
+
+    has_many(:blockee_blocks, UserRelationship,
+      foreign_key: :target_id,
+      where: [relationship_type: :block]
+    )
+
+    has_many(:blocked_users, through: [:blocker_blocks, :target])
+    has_many(:blocker_users, through: [:blockee_blocks, :source])
 
-    has_many(:muter_mutes, UserMute, foreign_key: :muter_id)
-    has_many(:mutee_mutes, UserMute, foreign_key: :mutee_id)
-    has_many(:muted_users, through: [:muter_mutes, :mutee])
-    has_many(:muter_users, through: [:mutee_mutes, :muter])
+    has_many(:muter_mutes, UserRelationship,
+      foreign_key: :source_id,
+      where: [relationship_type: :mute]
+    )
+
+    has_many(:mutee_mutes, UserRelationship,
+      foreign_key: :target_id,
+      where: [relationship_type: :mute]
+    )
+
+    has_many(:muted_users, through: [:muter_mutes, :target])
+    has_many(:muter_users, through: [:mutee_mutes, :source])
 
     field(:info, :map, default: %{})
 
     # `:blocks` is deprecated (replaced with `blocked_users` relation)
     field(:blocks, {:array, :string}, default: [])
+    # `:mutes` is deprecated (replaced with `muted_users` relation)
+    field(:mutes, {:array, :string}, default: [])
 
     timestamps()
   end
@@ -1054,7 +1073,7 @@ defmodule Pleroma.User do
   def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
 
   def mutes_user?(%User{} = user, %User{} = target) do
-    UserMute.exists?(user, target)
+    UserRelationship.mute_exists?(user, target)
   end
 
   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
@@ -1070,7 +1089,7 @@ defmodule Pleroma.User do
   end
 
   def blocks_user?(%User{} = user, %User{} = target) do
-    UserBlock.exists?(user, target)
+    UserRelationship.block_exists?(user, target)
   end
 
   def blocks_user?(_, _), do: false
@@ -1119,33 +1138,20 @@ defmodule Pleroma.User do
     |> Repo.all()
   end
 
-  defp related_ap_ids_sql(join_table, source_column, target_column) do
-    "(SELECT array_agg(u.ap_id) FROM users as u " <>
-      "INNER JOIN #{join_table} AS join_table " <>
-      "ON join_table.#{source_column} = $1 " <>
-      "WHERE u.id = join_table.#{target_column})"
-  end
-
-  @related_ap_ids_sql_params %{
-    blocked_users: ["user_blocks", "blocker_id", "blockee_id"],
-    muted_users: ["user_mutes", "muter_id", "mutee_id"]
-  }
-
-  def related_ap_ids(user, relations) when is_list(relations) do
-    query =
-      relations
-      |> Enum.map(fn r -> @related_ap_ids_sql_params[r] end)
-      |> Enum.filter(& &1)
-      |> Enum.map(fn [join_table, source_column, target_column] ->
-        related_ap_ids_sql(join_table, source_column, target_column)
-      end)
-      |> Enum.join(", ")
-
-    with {:ok, %{rows: [ap_ids_arrays]}} <-
-           Repo.query("SELECT #{query}", [FlakeId.from_string(user.id)]) do
-      ap_ids_arrays = Enum.map(ap_ids_arrays, &(&1 || []))
-      {:ok, ap_ids_arrays}
-    end
+  @doc """
+  Returns map of related AP IDs list by relation type.
+  E.g. `related_ap_ids(user, [:blocks])` -> `%{blocks: ["https://some.site/users/userapid"]}`
+  """
+  @spec related_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
+  def related_ap_ids(%User{} = user, relationship_types) when is_list(relationship_types) do
+    user
+    |> assoc(:outgoing_relationships)
+    |> join(:inner, [user_rel], u in assoc(user_rel, :target))
+    |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
+    |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
+    |> group_by([user_rel, u], user_rel.relationship_type)
+    |> Repo.all()
+    |> Enum.into(%{}, fn [k, v] -> {k, v} end)
   end
 
   @spec subscribers(User.t()) :: [User.t()]
@@ -1918,19 +1924,20 @@ defmodule Pleroma.User do
     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
   end
 
-  @spec add_to_block(User.t(), User.t()) :: {:ok, UserBlock.t()} | {:error, Ecto.Changeset.t()}
+  @spec add_to_block(User.t(), User.t()) ::
+          {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
   defp add_to_block(%User{} = user, %User{} = blocked) do
-    UserBlock.create(user, blocked)
+    UserRelationship.create_block(user, blocked)
   end
 
   @spec add_to_block(User.t(), User.t()) ::
-          {:ok, UserBlock.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
+          {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
   defp remove_from_block(%User{} = user, %User{} = blocked) do
-    UserBlock.delete(user, blocked)
+    UserRelationship.delete_block(user, blocked)
   end
 
   defp add_to_mutes(%User{} = user, %User{ap_id: ap_id} = muted_user, notifications?) do
-    with {:ok, user_mute} <- UserMute.create(user, muted_user),
+    with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
          {:ok, _user} <-
            set_notification_mutes(
              user,
@@ -1942,7 +1949,7 @@ defmodule Pleroma.User do
   end
 
   defp remove_from_mutes(user, %User{ap_id: ap_id} = muted_user) do
-    with {:ok, user_mute} <- UserMute.delete(user, muted_user),
+    with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
          {:ok, _user} <-
            set_notification_mutes(
              user,
diff --git a/lib/pleroma/user/search.ex b/lib/pleroma/user/search.ex
index 049e1a634..2b3c7b5b4 100644
--- a/lib/pleroma/user/search.ex
+++ b/lib/pleroma/user/search.ex
@@ -100,11 +100,11 @@ defmodule Pleroma.User.Search do
 
   defp filter_blocked_user(query, %User{} = blocker) do
     query
-    |> join(:left, [u], b in Pleroma.UserBlock,
+    |> join(:left, [u], b in Pleroma.UserRelationship,
       as: :blocks,
-      on: b.blocker_id == ^blocker.id and u.id == b.blockee_id
+      on: b.relationship_type == ^:block and b.source_id == ^blocker.id and u.id == b.target_id
     )
-    |> where([blocks: b], is_nil(b.blockee_id))
+    |> where([blocks: b], is_nil(b.target_id))
   end
 
   defp filter_blocked_user(query, _), do: query
diff --git a/lib/pleroma/user_block.ex b/lib/pleroma/user_block.ex
deleted file mode 100644
index bcf4b64d9..000000000
--- a/lib/pleroma/user_block.ex
+++ /dev/null
@@ -1,71 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.UserBlock do
-  use Ecto.Schema
-
-  import Ecto.Changeset
-  import Ecto.Query
-
-  alias Pleroma.Repo
-  alias Pleroma.User
-  alias Pleroma.UserBlock
-
-  schema "user_blocks" do
-    belongs_to(:blocker, User, type: FlakeId.Ecto.CompatType)
-    belongs_to(:blockee, User, type: FlakeId.Ecto.CompatType)
-
-    timestamps(updated_at: false)
-  end
-
-  def changeset(%UserBlock{} = user_block, params \\ %{}) do
-    user_block
-    |> cast(params, [:blocker_id, :blockee_id])
-    |> validate_required([:blocker_id, :blockee_id])
-    |> unique_constraint(:blockee_id, name: :user_blocks_blocker_id_blockee_id_index)
-    |> validate_not_self_block()
-  end
-
-  def exists?(%User{} = blocker, %User{} = blockee) do
-    UserBlock
-    |> where(blocker_id: ^blocker.id, blockee_id: ^blockee.id)
-    |> Repo.exists?()
-  end
-
-  def create(%User{} = blocker, %User{} = blockee) do
-    %UserBlock{}
-    |> changeset(%{blocker_id: blocker.id, blockee_id: blockee.id})
-    |> Repo.insert(
-      on_conflict: :replace_all_except_primary_key,
-      conflict_target: [:blocker_id, :blockee_id]
-    )
-  end
-
-  def delete(%User{} = blocker, %User{} = blockee) do
-    attrs = %{blocker_id: blocker.id, blockee_id: blockee.id}
-
-    case Repo.get_by(UserBlock, attrs) do
-      %UserBlock{} = existing_record -> Repo.delete(existing_record)
-      nil -> {:ok, nil}
-    end
-  end
-
-  defp validate_not_self_block(%Ecto.Changeset{} = changeset) do
-    changeset
-    |> validate_change(:blockee_id, fn _, blockee_id ->
-      if blockee_id == get_field(changeset, :blocker_id) do
-        [blockee_id: "can't be equal to blocker_id"]
-      else
-        []
-      end
-    end)
-    |> validate_change(:blocker_id, fn _, blocker_id ->
-      if blocker_id == get_field(changeset, :blockee_id) do
-        [blocker_id: "can't be equal to blockee_id"]
-      else
-        []
-      end
-    end)
-  end
-end
diff --git a/lib/pleroma/user_mute.ex b/lib/pleroma/user_mute.ex
deleted file mode 100644
index 417a5ff84..000000000
--- a/lib/pleroma/user_mute.ex
+++ /dev/null
@@ -1,71 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.UserMute do
-  use Ecto.Schema
-
-  import Ecto.Changeset
-  import Ecto.Query
-
-  alias Pleroma.Repo
-  alias Pleroma.User
-  alias Pleroma.UserMute
-
-  schema "user_mutes" do
-    belongs_to(:muter, User, type: FlakeId.Ecto.CompatType)
-    belongs_to(:mutee, User, type: FlakeId.Ecto.CompatType)
-
-    timestamps(updated_at: false)
-  end
-
-  def changeset(%UserMute{} = user_mute, params \\ %{}) do
-    user_mute
-    |> cast(params, [:muter_id, :mutee_id])
-    |> validate_required([:muter_id, :mutee_id])
-    |> unique_constraint(:mutee_id, name: :user_mutes_muter_id_mutee_id_index)
-    |> validate_not_self_mute()
-  end
-
-  def exists?(%User{} = muter, %User{} = mutee) do
-    UserMute
-    |> where(muter_id: ^muter.id, mutee_id: ^mutee.id)
-    |> Repo.exists?()
-  end
-
-  def create(%User{} = muter, %User{} = mutee) do
-    %UserMute{}
-    |> changeset(%{muter_id: muter.id, mutee_id: mutee.id})
-    |> Repo.insert(
-      on_conflict: :replace_all_except_primary_key,
-      conflict_target: [:muter_id, :mutee_id]
-    )
-  end
-
-  def delete(%User{} = muter, %User{} = mutee) do
-    attrs = %{muter_id: muter.id, mutee_id: mutee.id}
-
-    case Repo.get_by(UserMute, attrs) do
-      %UserMute{} = existing_record -> Repo.delete(existing_record)
-      nil -> {:ok, nil}
-    end
-  end
-
-  defp validate_not_self_mute(%Ecto.Changeset{} = changeset) do
-    changeset
-    |> validate_change(:mutee_id, fn _, mutee_id ->
-      if mutee_id == get_field(changeset, :muter_id) do
-        [mutee_id: "can't be equal to muter_id"]
-      else
-        []
-      end
-    end)
-    |> validate_change(:muter_id, fn _, muter_id ->
-      if muter_id == get_field(changeset, :mutee_id) do
-        [muter_id: "can't be equal to mutee_id"]
-      else
-        []
-      end
-    end)
-  end
-end
diff --git a/lib/pleroma/user_relationship.ex b/lib/pleroma/user_relationship.ex
new file mode 100644
index 000000000..5cb99ae50
--- /dev/null
+++ b/lib/pleroma/user_relationship.ex
@@ -0,0 +1,90 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.UserRelationship do
+  use Ecto.Schema
+
+  import Ecto.Changeset
+  import Ecto.Query
+
+  alias Pleroma.Repo
+  alias Pleroma.User
+  alias Pleroma.UserRelationship
+
+  schema "user_relationships" do
+    belongs_to(:source, User, type: FlakeId.Ecto.CompatType)
+    belongs_to(:target, User, type: FlakeId.Ecto.CompatType)
+    field(:relationship_type, UserRelationshipTypeEnum)
+
+    timestamps(updated_at: false)
+  end
+
+  def changeset(%UserRelationship{} = user_relationship, params \\ %{}) do
+    user_relationship
+    |> cast(params, [:relationship_type, :source_id, :target_id])
+    |> validate_required([:relationship_type, :source_id, :target_id])
+    |> unique_constraint(:relationship_type,
+      name: :user_relationships_source_id_relationship_type_target_id_index
+    )
+    |> validate_not_self_relationship()
+  end
+
+  def exists?(relationship_type, %User{} = source, %User{} = target) do
+    UserRelationship
+    |> where(relationship_type: ^relationship_type, source_id: ^source.id, target_id: ^target.id)
+    |> Repo.exists?()
+  end
+
+  def block_exists?(%User{} = blocker, %User{} = blockee), do: exists?(:block, blocker, blockee)
+
+  def mute_exists?(%User{} = muter, %User{} = mutee), do: exists?(:mute, muter, mutee)
+
+  def create(relationship_type, %User{} = source, %User{} = target) do
+    %UserRelationship{}
+    |> changeset(%{
+      relationship_type: relationship_type,
+      source_id: source.id,
+      target_id: target.id
+    })
+    |> Repo.insert(
+      on_conflict: :replace_all_except_primary_key,
+      conflict_target: [:source_id, :relationship_type, :target_id]
+    )
+  end
+
+  def create_block(%User{} = blocker, %User{} = blockee), do: create(:block, blocker, blockee)
+
+  def create_mute(%User{} = muter, %User{} = mutee), do: create(:mute, muter, mutee)
+
+  def delete(relationship_type, %User{} = source, %User{} = target) do
+    attrs = %{relationship_type: relationship_type, source_id: source.id, target_id: target.id}
+
+    case Repo.get_by(UserRelationship, attrs) do
+      %UserRelationship{} = existing_record -> Repo.delete(existing_record)
+      nil -> {:ok, nil}
+    end
+  end
+
+  def delete_block(%User{} = blocker, %User{} = blockee), do: delete(:block, blocker, blockee)
+
+  def delete_mute(%User{} = muter, %User{} = mutee), do: delete(:mute, muter, mutee)
+
+  defp validate_not_self_relationship(%Ecto.Changeset{} = changeset) do
+    changeset
+    |> validate_change(:target_id, fn _, target_id ->
+      if target_id == get_field(changeset, :source_id) do
+        [target_id: "can't be equal to source_id"]
+      else
+        []
+      end
+    end)
+    |> validate_change(:source_id, fn _, source_id ->
+      if source_id == get_field(changeset, :target_id) do
+        [source_id: "can't be equal to target_id"]
+      else
+        []
+      end
+    end)
+  end
+end
diff --git a/lib/pleroma/web/streamer/worker.ex b/lib/pleroma/web/streamer/worker.ex
index 45f9c7c53..020112949 100644
--- a/lib/pleroma/web/streamer/worker.ex
+++ b/lib/pleroma/web/streamer/worker.ex
@@ -129,7 +129,9 @@ defmodule Pleroma.Web.Streamer.Worker do
   end
 
   defp should_send?(%User{} = user, %Activity{} = item) do
-    {:ok, [blocks, mutes]} = User.related_ap_ids(user, [:blocked_users, :muted_users])
+    related_ap_ids = User.related_ap_ids(user, [:block, :mute])
+    blocks = related_ap_ids[:block] || []
+    mutes = related_ap_ids[:mute] || []
     reblog_mutes = user.muted_reblogs || []
     recipient_blocks = MapSet.new(blocks ++ mutes)
     recipients = MapSet.new(item.recipients)