aboutsummaryrefslogtreecommitdiff
path: root/lib/pleroma
diff options
context:
space:
mode:
Diffstat (limited to 'lib/pleroma')
-rw-r--r--lib/pleroma/ecto_enums.ex7
-rw-r--r--lib/pleroma/notification.ex4
-rw-r--r--lib/pleroma/user.ex177
-rw-r--r--lib/pleroma/user/search.ex10
-rw-r--r--lib/pleroma/user_relationship.ex90
-rw-r--r--lib/pleroma/web/activity_pub/activity_pub.ex12
-rw-r--r--lib/pleroma/web/mastodon_api/controllers/account_controller.ex12
-rw-r--r--lib/pleroma/web/mastodon_api/views/account_view.ex4
-rw-r--r--lib/pleroma/web/streamer/worker.ex5
9 files changed, 248 insertions, 73 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/notification.ex b/lib/pleroma/notification.ex
index b7ecf51e4..82faef85e 100644
--- a/lib/pleroma/notification.ex
+++ b/lib/pleroma/notification.ex
@@ -60,8 +60,10 @@ defmodule Pleroma.Notification do
end
defp exclude_blocked(query, user) do
+ blocked_ap_ids = User.blocked_ap_ids(user)
+
query
- |> where([n, a], a.actor not in ^user.blocks)
+ |> where([n, a], a.actor not in ^blocked_ap_ids)
|> where(
[n, a],
fragment("substring(? from '.*://([^/]*)')", a.actor) not in ^user.domain_blocks
diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
index fcb1d5143..4dd03c6c6 100644
--- a/lib/pleroma/user.ex
+++ b/lib/pleroma/user.ex
@@ -7,6 +7,7 @@ defmodule Pleroma.User do
import Ecto.Changeset
import Ecto.Query
+ import Ecto, only: [assoc: 2]
alias Comeonin.Pbkdf2
alias Ecto.Multi
@@ -21,6 +22,7 @@ defmodule Pleroma.User do
alias Pleroma.Repo
alias Pleroma.RepoStreamer
alias Pleroma.User
+ alias Pleroma.UserRelationship
alias Pleroma.Web
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.ActivityPub.Utils
@@ -74,9 +76,7 @@ defmodule Pleroma.User do
field(:password_reset_pending, :boolean, default: false)
field(:confirmation_token, :string, default: nil)
field(:default_scope, :string, default: "public")
- field(:blocks, {:array, :string}, default: [])
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: [])
@@ -119,8 +119,42 @@ defmodule Pleroma.User do
has_many(:registrations, Registration)
has_many(:deliveries, Delivery)
+ 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, 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
@@ -963,12 +997,12 @@ defmodule Pleroma.User do
end
@spec mute(User.t(), User.t(), boolean()) :: {:ok, User.t()} | {:error, String.t()}
- def mute(muter, %User{ap_id: ap_id}, notifications? \\ true) do
- add_to_mutes(muter, ap_id, notifications?)
+ def mute(muter, %User{} = mutee, notifications? \\ true) do
+ add_to_mutes(muter, mutee, notifications?)
end
- def unmute(muter, %{ap_id: ap_id}) do
- remove_from_mutes(muter, ap_id)
+ def unmute(muter, %User{} = mutee) do
+ remove_from_mutes(muter, mutee)
end
def subscribe(subscriber, %{ap_id: ap_id}) do
@@ -989,7 +1023,7 @@ defmodule Pleroma.User do
end
end
- def block(blocker, %User{ap_id: ap_id} = blocked) do
+ def block(blocker, %User{} = blocked) do
# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
blocker =
if following?(blocker, blocked) do
@@ -1018,7 +1052,7 @@ defmodule Pleroma.User do
{:ok, blocker} = update_follower_count(blocker)
{:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
- add_to_block(blocker, ap_id)
+ add_to_block(blocker, blocked)
end
# helper to handle the block given only an actor's AP id
@@ -1026,12 +1060,21 @@ defmodule Pleroma.User do
block(blocker, get_cached_by_ap_id(ap_id))
end
+ def unblock(blocker, %User{} = blocked) do
+ remove_from_block(blocker, blocked)
+ end
+
+ # helper to handle the block given only an actor's AP id
def unblock(blocker, %{ap_id: ap_id}) do
- remove_from_block(blocker, ap_id)
+ unblock(blocker, get_cached_by_ap_id(ap_id))
end
def mutes?(nil, _), do: false
- def mutes?(user, %{ap_id: ap_id}), do: Enum.member?(user.mutes, ap_id)
+ def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
+
+ def mutes_user?(%User{} = user, %User{} = target) do
+ UserRelationship.mute_exists?(user, target)
+ end
@spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
def muted_notifications?(nil, _), do: false
@@ -1039,17 +1082,17 @@ defmodule Pleroma.User do
def muted_notifications?(user, %{ap_id: ap_id}),
do: Enum.member?(user.muted_notifications, ap_id)
+ def blocks?(nil, _), do: false
+
def blocks?(%User{} = user, %User{} = target) do
- blocks_ap_id?(user, target) || blocks_domain?(user, target)
+ blocks_user?(user, target) || blocks_domain?(user, target)
end
- def blocks?(nil, _), do: false
-
- def blocks_ap_id?(%User{} = user, %User{} = target) do
- Enum.member?(user.blocks, target.ap_id)
+ def blocks_user?(%User{} = user, %User{} = target) do
+ UserRelationship.block_exists?(user, target)
end
- def blocks_ap_id?(_, _), do: false
+ def blocks_user?(_, _), do: false
def blocks_domain?(%User{} = user, %User{} = target) do
domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
@@ -1067,14 +1110,48 @@ defmodule Pleroma.User do
@spec muted_users(User.t()) :: [User.t()]
def muted_users(user) do
- User.Query.build(%{ap_id: user.mutes, deactivated: false})
+ user
+ |> assoc(:muted_users)
+ |> restrict_deactivated()
+ |> Repo.all()
+ end
+
+ def muted_ap_ids(user) do
+ user
+ |> assoc(:muted_users)
+ |> select([u], u.ap_id)
|> Repo.all()
end
@spec blocked_users(User.t()) :: [User.t()]
def blocked_users(user) do
- User.Query.build(%{ap_id: user.blocks, deactivated: false})
+ user
+ |> assoc(:blocked_users)
+ |> restrict_deactivated()
+ |> Repo.all()
+ end
+
+ def blocked_ap_ids(user) do
+ user
+ |> assoc(:blocked_users)
+ |> select([u], u.ap_id)
+ |> Repo.all()
+ 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()]
@@ -1182,7 +1259,7 @@ defmodule Pleroma.User do
blocked_identifiers,
fn blocked_identifier ->
with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
- {:ok, blocker} <- block(blocker, blocked),
+ {:ok, _user_block} <- block(blocker, blocked),
{:ok, _} <- ActivityPub.block(blocker, blocked) do
blocked
else
@@ -1847,49 +1924,39 @@ defmodule Pleroma.User do
set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
end
- defp set_blocks(user, blocks) do
- params = %{blocks: blocks}
-
- user
- |> cast(params, [:blocks])
- |> validate_required([:blocks])
- |> update_and_set_cache()
+ @spec add_to_block(User.t(), User.t()) ::
+ {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
+ defp add_to_block(%User{} = user, %User{} = blocked) do
+ UserRelationship.create_block(user, blocked)
end
- def add_to_block(user, blocked) do
- set_blocks(user, Enum.uniq([blocked | user.blocks]))
+ @spec add_to_block(User.t(), User.t()) ::
+ {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
+ defp remove_from_block(%User{} = user, %User{} = blocked) do
+ UserRelationship.delete_block(user, blocked)
end
- def remove_from_block(user, blocked) do
- set_blocks(user, List.delete(user.blocks, blocked))
- end
-
- defp set_mutes(user, mutes) do
- params = %{mutes: mutes}
-
- user
- |> cast(params, [:mutes])
- |> validate_required([:mutes])
- |> update_and_set_cache()
- end
-
- def add_to_mutes(user, muted, notifications?) do
- with {:ok, user} <- set_mutes(user, Enum.uniq([muted | user.mutes])) do
- set_notification_mutes(
- user,
- Enum.uniq([muted | user.muted_notifications]),
- notifications?
- )
+ defp add_to_mutes(%User{} = user, %User{ap_id: ap_id} = muted_user, notifications?) do
+ with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
+ {:ok, _user} <-
+ set_notification_mutes(
+ user,
+ Enum.uniq([ap_id | user.muted_notifications]),
+ notifications?
+ ) do
+ {:ok, user_mute}
end
end
- def remove_from_mutes(user, muted) do
- with {:ok, user} <- set_mutes(user, List.delete(user.mutes, muted)) do
- set_notification_mutes(
- user,
- List.delete(user.muted_notifications, muted),
- true
- )
+ defp remove_from_mutes(user, %User{ap_id: ap_id} = muted_user) do
+ with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
+ {:ok, _user} <-
+ set_notification_mutes(
+ user,
+ List.delete(user.muted_notifications, ap_id),
+ true
+ ) do
+ {:ok, user_mute}
end
end
diff --git a/lib/pleroma/user/search.ex b/lib/pleroma/user/search.ex
index 09664db76..2b3c7b5b4 100644
--- a/lib/pleroma/user/search.ex
+++ b/lib/pleroma/user/search.ex
@@ -98,9 +98,13 @@ defmodule Pleroma.User.Search do
defp base_query(_user, false), do: User
defp base_query(user, true), do: User.get_followers_query(user)
- defp filter_blocked_user(query, %User{blocks: blocks})
- when length(blocks) > 0 do
- from(q in query, where: not (q.ap_id in ^blocks))
+ defp filter_blocked_user(query, %User{} = blocker) do
+ query
+ |> join(:left, [u], b in Pleroma.UserRelationship,
+ as: :blocks,
+ on: b.relationship_type == ^:block and b.source_id == ^blocker.id and u.id == b.target_id
+ )
+ |> where([blocks: b], is_nil(b.target_id))
end
defp filter_blocked_user(query, _), do: query
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/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
index d0c014e9d..7a4a4791e 100644
--- a/lib/pleroma/web/activity_pub/activity_pub.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
@@ -884,7 +884,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
- mutes = user.mutes
+ mutes = opts["muted_ap_ids"] || User.muted_ap_ids(user)
query =
from([activity] in query,
@@ -901,8 +901,8 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
defp restrict_muted(query, _), do: query
- defp restrict_blocked(query, %{"blocking_user" => %User{} = user}) do
- blocks = user.blocks || []
+ defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
+ blocked_ap_ids = opts["blocked_ap_ids"] || User.blocked_ap_ids(user)
domain_blocks = user.domain_blocks || []
query =
@@ -910,14 +910,14 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
from(
[activity, object: o] in query,
- where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
- where: fragment("not (? && ?)", activity.recipients, ^blocks),
+ where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
+ where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
where:
fragment(
"not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
activity.data,
activity.data,
- ^blocks
+ ^blocked_ap_ids
),
where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks),
where: fragment("not (split_part(?->>'actor', '/', 3) = ANY(?))", o.data, ^domain_blocks)
diff --git a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
index 5b01b964b..750f5c690 100644
--- a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
+++ b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
@@ -323,7 +323,9 @@ defmodule Pleroma.Web.MastodonAPI.AccountController do
def mute(%{assigns: %{user: muter, account: muted}} = conn, params) do
notifications? = params |> Map.get("notifications", true) |> truthy_param?()
- with {:ok, muter} <- User.mute(muter, muted, notifications?) do
+ with {:ok, _user_mute} <- User.mute(muter, muted, notifications?) do
+ # TODO: remove `muter` refresh once `muted_notifications` field is deprecated
+ muter = User.get_cached_by_id(muter.id)
render(conn, "relationship.json", user: muter, target: muted)
else
{:error, message} -> json_response(conn, :forbidden, %{error: message})
@@ -332,7 +334,9 @@ defmodule Pleroma.Web.MastodonAPI.AccountController do
@doc "POST /api/v1/accounts/:id/unmute"
def unmute(%{assigns: %{user: muter, account: muted}} = conn, _params) do
- with {:ok, muter} <- User.unmute(muter, muted) do
+ with {:ok, _user_mute} <- User.unmute(muter, muted) do
+ # TODO: remove `muter` refresh once `muted_notifications` field is deprecated
+ muter = User.get_cached_by_id(muter.id)
render(conn, "relationship.json", user: muter, target: muted)
else
{:error, message} -> json_response(conn, :forbidden, %{error: message})
@@ -341,7 +345,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountController do
@doc "POST /api/v1/accounts/:id/block"
def block(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
- with {:ok, blocker} <- User.block(blocker, blocked),
+ with {:ok, _user_block} <- User.block(blocker, blocked),
{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
render(conn, "relationship.json", user: blocker, target: blocked)
else
@@ -351,7 +355,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountController do
@doc "POST /api/v1/accounts/:id/unblock"
def unblock(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
- with {:ok, blocker} <- User.unblock(blocker, blocked),
+ with {:ok, _user_block} <- User.unblock(blocker, blocked),
{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
render(conn, "relationship.json", user: blocker, target: blocked)
else
diff --git a/lib/pleroma/web/mastodon_api/views/account_view.ex b/lib/pleroma/web/mastodon_api/views/account_view.ex
index e30fed610..37dc8e194 100644
--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
@@ -50,8 +50,8 @@ defmodule Pleroma.Web.MastodonAPI.AccountView do
id: to_string(target.id),
following: User.following?(user, target),
followed_by: User.following?(target, user),
- blocking: User.blocks_ap_id?(user, target),
- blocked_by: User.blocks_ap_id?(target, user),
+ blocking: User.blocks_user?(user, target),
+ blocked_by: User.blocks_user?(target, user),
muting: User.mutes?(user, target),
muting_notifications: User.muted_notifications?(user, target),
subscribing: User.subscribed_to?(user, target),
diff --git a/lib/pleroma/web/streamer/worker.ex b/lib/pleroma/web/streamer/worker.ex
index 33b24840d..020112949 100644
--- a/lib/pleroma/web/streamer/worker.ex
+++ b/lib/pleroma/web/streamer/worker.ex
@@ -129,8 +129,9 @@ defmodule Pleroma.Web.Streamer.Worker do
end
defp should_send?(%User{} = user, %Activity{} = item) do
- blocks = user.blocks || []
- mutes = user.mutes || []
+ 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)
generated by cgit v1.2.3 (git 2.26.2) at 2025-04-26 07:32:15 +0000