No OneTemporary
Actions

Size

220 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/filter.ex b/lib/pleroma/filter.ex
	index e827d3cbc..8c62d761f 100644
	--- a/lib/pleroma/filter.ex
	+++ b/lib/pleroma/filter.ex
	@@ -1,223 +1,235 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Filter do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query

	alias Pleroma.Repo
	alias Pleroma.User

	@type t() :: %__MODULE__{}
	@type format() :: :postgres \| :re

	schema "filters" do
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	field(:filter_id, :integer)
	field(:hide, :boolean, default: false)
	field(:whole_word, :boolean, default: true)
	field(:phrase, :string)
	field(:context, {:array, :string})
	field(:expires_at, :naive_datetime)

	timestamps()
	end

	@spec get(integer() \| String.t(), User.t()) :: t() \| nil
	def get(id, %{id: user_id} = _user) do
	query =
	from(
	f in __MODULE__,
	where: f.filter_id == ^id,
	where: f.user_id == ^user_id
	)

	Repo.one(query)
	end

	@spec get_active(Ecto.Query.t() \| module()) :: Ecto.Query.t()
	def get_active(query) do
	from(f in query, where: is_nil(f.expires_at) or f.expires_at > ^NaiveDateTime.utc_now())
	end

	@spec get_irreversible(Ecto.Query.t()) :: Ecto.Query.t()
	def get_irreversible(query) do
	from(f in query, where: f.hide)
	end

	+ @spec get_context(Ecto.Query.t(), String.t()) :: Ecto.Query.t()
	+ def get_context(query, context) do
	+ from(
	+ f in query,
	+ where: ^context in f.context
	+ )
	+ end
	+
	@spec get_filters(Ecto.Query.t() \| module(), User.t()) :: [t()]
	def get_filters(query \\ __MODULE__, %User{id: user_id}) do
	query =
	from(
	f in query,
	where: f.user_id == ^user_id,
	order_by: [desc: :id]
	)

	Repo.all(query)
	end

	@spec create(map()) :: {:ok, t()} \| {:error, Ecto.Changeset.t()}
	def create(attrs \\ %{}) do
	Repo.transaction(fn -> create_with_expiration(attrs) end)
	end

	defp create_with_expiration(attrs) do
	with {:ok, filter} <- do_create(attrs),
	{:ok, _} <- maybe_add_expiration_job(filter) do
	filter
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	defp do_create(attrs) do
	%__MODULE__{}
	\|> cast(attrs, [:phrase, :context, :hide, :expires_at, :whole_word, :user_id, :filter_id])
	\|> maybe_add_filter_id()
	\|> validate_required([:phrase, :context, :user_id, :filter_id])
	\|> maybe_add_expires_at(attrs)
	\|> Repo.insert()
	end

	defp maybe_add_filter_id(%{changes: %{filter_id: _}} = changeset), do: changeset

	defp maybe_add_filter_id(%{changes: %{user_id: user_id}} = changeset) do
	# If filter_id wasn't given, use the max filter_id for this user plus 1.
	# XXX This could result in a race condition if a user tries to add two
	# different filters for their account from two different clients at the
	# same time, but that should be unlikely.

	max_id_query =
	from(
	f in __MODULE__,
	where: f.user_id == ^user_id,
	select: max(f.filter_id)
	)

	filter_id =
	case Repo.one(max_id_query) do
	# Start allocating from 1
	nil ->
	1

	max_id ->
	max_id + 1
	end

	change(changeset, filter_id: filter_id)
	end

	# don't override expires_at, if passed expires_at and expires_in
	defp maybe_add_expires_at(%{changes: %{expires_at: %NaiveDateTime{} = _}} = changeset, _) do
	changeset
	end

	defp maybe_add_expires_at(changeset, %{expires_in: expires_in})
	when is_integer(expires_in) and expires_in > 0 do
	expires_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(expires_in)
	\|> NaiveDateTime.truncate(:second)

	change(changeset, expires_at: expires_at)
	end

	defp maybe_add_expires_at(changeset, %{expires_in: nil}) do
	change(changeset, expires_at: nil)
	end

	defp maybe_add_expires_at(changeset, _), do: changeset

	defp maybe_add_expiration_job(%{expires_at: %NaiveDateTime{} = expires_at} = filter) do
	Pleroma.Workers.PurgeExpiredFilter.enqueue(%{
	filter_id: filter.id,
	expires_at: DateTime.from_naive!(expires_at, "Etc/UTC")
	})
	end

	defp maybe_add_expiration_job(_), do: {:ok, nil}

	@spec delete(t()) :: {:ok, t()} \| {:error, Ecto.Changeset.t()}
	def delete(%__MODULE__{} = filter) do
	Repo.transaction(fn -> delete_with_expiration(filter) end)
	end

	defp delete_with_expiration(filter) do
	with {:ok, _} <- maybe_delete_old_expiration_job(filter, nil),
	{:ok, filter} <- Repo.delete(filter) do
	filter
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec update(t(), map()) :: {:ok, t()} \| {:error, Ecto.Changeset.t()}
	def update(%__MODULE__{} = filter, params) do
	Repo.transaction(fn -> update_with_expiration(filter, params) end)
	end

	defp update_with_expiration(filter, params) do
	with {:ok, updated} <- do_update(filter, params),
	{:ok, _} <- maybe_delete_old_expiration_job(filter, updated),
	{:ok, _} <-
	maybe_add_expiration_job(updated) do
	updated
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	defp do_update(filter, params) do
	filter
	\|> cast(params, [:phrase, :context, :hide, :expires_at, :whole_word])
	\|> validate_required([:phrase, :context])
	\|> maybe_add_expires_at(params)
	\|> Repo.update()
	end

	defp maybe_delete_old_expiration_job(%{expires_at: nil}, _), do: {:ok, nil}

	defp maybe_delete_old_expiration_job(%{expires_at: expires_at}, %{expires_at: expires_at}) do
	{:ok, nil}
	end

	defp maybe_delete_old_expiration_job(%{id: id}, _) do
	with %Oban.Job{} = job <- Pleroma.Workers.PurgeExpiredFilter.get_expiration(id) do
	Repo.delete(job)
	else
	nil -> {:ok, nil}
	end
	end

	- @spec compose_regex(User.t() \| [t()], format()) :: String.t() \| Regex.t() \| nil
	- def compose_regex(user_or_filters, format \\ :postgres)
	+ @spec compose_regex(User.t(), String.t(), format()) :: String.t() \| Regex.t() \| nil
	+ def compose_regex(user, context, format \\ :postgres)

	- def compose_regex(%User{} = user, format) do
	+ def compose_regex(%User{} = user, context, format)
	+ when context in ["home", "notifications"] do
	__MODULE__
	\|> get_active()
	\|> get_irreversible()
	+ \|> get_context(context)
	\|> get_filters(user)
	- \|> compose_regex(format)
	+ \|> to_regex(format)
	end

	- def compose_regex([_ \| _] = filters, format) do
	+ def compose_regex(_, _, _), do: nil
	+
	+ defp to_regex([_ \| _] = filters, format) do
	phrases =
	filters
	\|> Enum.map(& &1.phrase)
	\|> Enum.join("\|")

	case format do
	:postgres ->
	"\\y(#{phrases})\\y"

	:re ->
	~r/\b#{phrases}\b/i
	end
	end

	- def compose_regex(_, _), do: nil
	+ defp to_regex(_, _), do: nil
	end
	diff --git a/lib/pleroma/notification.ex b/lib/pleroma/notification.ex
	index 75f4ba503..183724a85 100644
	--- a/lib/pleroma/notification.ex
	+++ b/lib/pleroma/notification.ex
	@@ -1,768 +1,768 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Notification do
	use Ecto.Schema

	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.FollowingRelationship
	alias Pleroma.Marker
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.Push
	alias Pleroma.Web.Streamer

	import Ecto.Query
	import Ecto.Changeset

	require Logger

	@type t :: %__MODULE__{}

	@include_muted_option :with_muted

	schema "notifications" do
	field(:seen, :boolean, default: false)
	# This is an enum type in the database. If you add a new notification type,
	# remember to add a migration to add it to the `notifications_type` enum
	# as well.
	field(:type, :string)
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	belongs_to(:activity, Activity, type: FlakeId.Ecto.CompatType)

	timestamps()
	end

	def update_notification_type(user, activity) do
	with %__MODULE__{} = notification <-
	Repo.get_by(__MODULE__, user_id: user.id, activity_id: activity.id) do
	type =
	activity
	\|> type_from_activity()

	notification
	\|> changeset(%{type: type})
	\|> Repo.update()
	end
	end

	@spec unread_notifications_count(User.t()) :: integer()
	def unread_notifications_count(%User{id: user_id}) do
	from(q in __MODULE__,
	where: q.user_id == ^user_id and q.seen == false
	)
	\|> Repo.aggregate(:count, :id)
	end

	@notification_types ~w{
	favourite
	follow
	follow_request
	mention
	move
	pleroma:chat_mention
	pleroma:emoji_reaction
	pleroma:report
	reblog
	poll
	status
	}

	def changeset(%Notification{} = notification, attrs) do
	notification
	\|> cast(attrs, [:seen, :type])
	\|> validate_inclusion(:type, @notification_types)
	end

	@spec last_read_query(User.t()) :: Ecto.Queryable.t()
	def last_read_query(user) do
	from(q in Pleroma.Notification,
	where: q.user_id == ^user.id,
	where: q.seen == true,
	select: type(q.id, :string),
	limit: 1,
	order_by: fragment("? desc nulls last", q.id)
	)
	end

	defp for_user_query_ap_id_opts(user, opts) do
	ap_id_relationships =
	[:block] ++
	if opts[@include_muted_option], do: [], else: [:notification_mute]

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(user, ap_id_relationships)

	exclude_blocked_opts = Map.merge(%{blocked_users_ap_ids: preloaded_ap_ids[:block]}, opts)

	exclude_notification_muted_opts =
	Map.merge(%{notification_muted_users_ap_ids: preloaded_ap_ids[:notification_mute]}, opts)

	{exclude_blocked_opts, exclude_notification_muted_opts}
	end

	def for_user_query(user, opts \\ %{}) do
	{exclude_blocked_opts, exclude_notification_muted_opts} =
	for_user_query_ap_id_opts(user, opts)

	Notification
	\|> where(user_id: ^user.id)
	\|> join(:inner, [n], activity in assoc(n, :activity))
	\|> join(:left, [n, a], object in Object,
	on:
	fragment(
	"(?->>'id') = associated_object_id(?)",
	object.data,
	a.data
	)
	)
	\|> join(:inner, [_n, a], u in User, on: u.ap_id == a.actor, as: :user_actor)
	\|> preload([n, a, o], activity: {a, object: o})
	\|> where([user_actor: user_actor], user_actor.is_active)
	\|> exclude_notification_muted(user, exclude_notification_muted_opts)
	\|> exclude_blocked(user, exclude_blocked_opts)
	\|> exclude_blockers(user)
	\|> exclude_filtered(user)
	\|> exclude_visibility(opts)
	end

	# Excludes blocked users and non-followed domain-blocked users
	defp exclude_blocked(query, user, opts) do
	blocked_ap_ids = opts[:blocked_users_ap_ids] \|\| User.blocked_users_ap_ids(user)

	query
	\|> where([..., user_actor: user_actor], user_actor.ap_id not in ^blocked_ap_ids)
	\|> FollowingRelationship.keep_following_or_not_domain_blocked(user)
	end

	defp exclude_blockers(query, user) do
	if Pleroma.Config.get([:activitypub, :blockers_visible]) == true do
	query
	else
	blocker_ap_ids = User.incoming_relationships_ungrouped_ap_ids(user, [:block])

	query
	\|> where([..., user_actor: user_actor], user_actor.ap_id not in ^blocker_ap_ids)
	end
	end

	defp exclude_notification_muted(query, _, %{@include_muted_option => true}) do
	query
	end

	defp exclude_notification_muted(query, user, opts) do
	notification_muted_ap_ids =
	opts[:notification_muted_users_ap_ids] \|\| User.notification_muted_users_ap_ids(user)

	query
	\|> where([..., user_actor: user_actor], user_actor.ap_id not in ^notification_muted_ap_ids)
	\|> join(:left, [n, a], tm in ThreadMute,
	on: tm.user_id == ^user.id and tm.context == fragment("?->>'context'", a.data),
	as: :thread_mute
	)
	\|> where([thread_mute: thread_mute], is_nil(thread_mute.user_id))
	end

	defp exclude_filtered(query, user) do
	- case Pleroma.Filter.compose_regex(user) do
	+ case Pleroma.Filter.compose_regex(user, "notifications") do
	nil ->
	query

	regex ->
	from([_n, a, o] in query,
	where:
	fragment("not(?->>'content' ~* ?)", o.data, ^regex) or
	fragment("?->>'content' is null", o.data) or
	fragment("?->>'actor' = ?", o.data, ^user.ap_id)
	)
	end
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	query
	\|> join(:left, [n, a], mutated_activity in Pleroma.Activity,
	on:
	fragment(
	"associated_object_id(?)",
	a.data
	) ==
	fragment(
	"associated_object_id(?)",
	mutated_activity.data
	) and
	fragment("(?->>'type' = 'Like' or ?->>'type' = 'Announce')", a.data, a.data) and
	fragment("?->>'type'", mutated_activity.data) == "Create",
	as: :mutated_activity
	)
	\|> where(
	[n, a, mutated_activity: mutated_activity],
	not fragment(
	"""
	CASE WHEN (?->>'type') = 'Like' or (?->>'type') = 'Announce'
	THEN (activity_visibility(?, ?, ?) = ANY (?))
	ELSE (activity_visibility(?, ?, ?) = ANY (?)) END
	""",
	a.data,
	a.data,
	mutated_activity.actor,
	mutated_activity.recipients,
	mutated_activity.data,
	^visibility,
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility in @valid_visibilities do
	exclude_visibility(query, [visibility])
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end

	defp exclude_visibility(query, _visibility), do: query

	def for_user(user, opts \\ %{}) do
	user
	\|> for_user_query(opts)
	\|> Pagination.fetch_paginated(opts)
	end

	@doc """
	Returns notifications for user received since given date.

	## Examples

	iex> Pleroma.Notification.for_user_since(%Pleroma.User{}, ~N[2019-04-13 11:22:33])
	[%Pleroma.Notification{}, %Pleroma.Notification{}]

	iex> Pleroma.Notification.for_user_since(%Pleroma.User{}, ~N[2019-04-15 11:22:33])
	[]
	"""
	@spec for_user_since(Pleroma.User.t(), NaiveDateTime.t()) :: [t()]
	def for_user_since(user, date) do
	from(n in for_user_query(user),
	where: n.updated_at > ^date
	)
	\|> Repo.all()
	end

	def set_read_up_to(%{id: user_id} = user, id) do
	query =
	from(
	n in Notification,
	where: n.user_id == ^user_id,
	where: n.id <= ^id,
	where: n.seen == false,
	# Ideally we would preload object and activities here
	# but Ecto does not support preloads in update_all
	select: n.id
	)

	Multi.new()
	\|> Multi.update_all(:ids, query, set: [seen: true, updated_at: NaiveDateTime.utc_now()])
	\|> Marker.multi_set_last_read_id(user, "notifications")
	\|> Repo.transaction()
	end

	@spec read_one(User.t(), String.t()) ::
	{:ok, Notification.t()} \| {:error, Ecto.Changeset.t()} \| nil
	def read_one(%User{} = user, notification_id) do
	with {:ok, %Notification{} = notification} <- get(user, notification_id) do
	Multi.new()
	\|> Multi.update(:update, changeset(notification, %{seen: true}))
	\|> Marker.multi_set_last_read_id(user, "notifications")
	\|> Repo.transaction()
	end
	end

	def get(%{id: user_id} = _user, id) do
	query =
	from(
	n in Notification,
	where: n.id == ^id,
	join: activity in assoc(n, :activity),
	preload: [activity: activity]
	)

	notification = Repo.one(query)

	case notification do
	%{user_id: ^user_id} ->
	{:ok, notification}

	_ ->
	{:error, "Cannot get notification"}
	end
	end

	def clear(user) do
	from(n in Notification, where: n.user_id == ^user.id)
	\|> Repo.delete_all()
	end

	def destroy_multiple(%{id: user_id} = _user, ids) do
	from(n in Notification,
	where: n.id in ^ids,
	where: n.user_id == ^user_id
	)
	\|> Repo.delete_all()
	end

	def dismiss(%Pleroma.Activity{} = activity) do
	Notification
	\|> where([n], n.activity_id == ^activity.id)
	\|> Repo.delete_all()
	\|> case do
	{_, notifications} -> {:ok, notifications}
	_ -> {:error, "Cannot dismiss notification"}
	end
	end

	def dismiss(%{id: user_id} = _user, id) do
	notification = Repo.get(Notification, id)

	case notification do
	%{user_id: ^user_id} ->
	Repo.delete(notification)

	_ ->
	{:error, "Cannot dismiss notification"}
	end
	end

	@spec create_notifications(Activity.t()) :: {:ok, [Notification.t()] \| []}
	def create_notifications(activity)

	def create_notifications(%Activity{data: %{"to" => _, "type" => "Create"}} = activity) do
	object = Object.normalize(activity, fetch: false)

	if object && object.data["type"] == "Answer" do
	{:ok, []}
	else
	do_create_notifications(activity)
	end
	end

	def create_notifications(%Activity{data: %{"type" => type}} = activity)
	when type in ["Follow", "Like", "Announce", "Move", "EmojiReact", "Flag", "Update"] do
	do_create_notifications(activity)
	end

	def create_notifications(_), do: {:ok, []}

	defp do_create_notifications(%Activity{} = activity) do
	enabled_receivers = get_notified_from_activity(activity)

	enabled_subscribers = get_notified_subscribers_from_activity(activity)

	notifications =
	(Enum.map(enabled_receivers, fn user ->
	create_notification(activity, user)
	end) ++
	Enum.map(enabled_subscribers -- enabled_receivers, fn user ->
	create_notification(activity, user, type: "status")
	end))
	\|> Enum.reject(&is_nil/1)

	{:ok, notifications}
	end

	defp type_from_activity(%{data: %{"type" => type}} = activity) do
	case type do
	"Follow" ->
	if Activity.follow_accepted?(activity) do
	"follow"
	else
	"follow_request"
	end

	"Announce" ->
	"reblog"

	"Like" ->
	"favourite"

	"Move" ->
	"move"

	"EmojiReact" ->
	"pleroma:emoji_reaction"

	"Flag" ->
	"pleroma:report"

	# Compatibility with old reactions
	"EmojiReaction" ->
	"pleroma:emoji_reaction"

	"Create" ->
	activity
	\|> type_from_activity_object()

	"Update" ->
	"update"

	t ->
	raise "No notification type for activity type #{t}"
	end
	end

	defp type_from_activity_object(%{data: %{"type" => "Create", "object" => %{}}}), do: "mention"

	defp type_from_activity_object(%{data: %{"type" => "Create"}} = activity) do
	object = Object.get_by_ap_id(activity.data["object"])

	case object && object.data["type"] do
	"ChatMessage" -> "pleroma:chat_mention"
	_ -> "mention"
	end
	end

	# TODO move to sql, too.
	def create_notification(%Activity{} = activity, %User{} = user, opts \\ []) do
	type = Keyword.get(opts, :type, type_from_activity(activity))

	unless skip?(activity, user, opts) do
	{:ok, %{notification: notification}} =
	Multi.new()
	\|> Multi.insert(:notification, %Notification{
	user_id: user.id,
	activity: activity,
	seen: mark_as_read?(activity, user),
	type: type
	})
	\|> Marker.multi_set_last_read_id(user, "notifications")
	\|> Repo.transaction()

	notification
	end
	end

	def create_poll_notifications(%Activity{} = activity) do
	with %Object{data: %{"type" => "Question", "actor" => actor} = data} <-
	Object.normalize(activity) do
	voters =
	case data do
	%{"voters" => voters} when is_list(voters) -> voters
	_ -> []
	end

	notifications =
	Enum.reduce([actor \| voters], [], fn ap_id, acc ->
	with %User{local: true} = user <- User.get_by_ap_id(ap_id) do
	[create_notification(activity, user, type: "poll") \| acc]
	else
	_ -> acc
	end
	end)

	{:ok, notifications}
	end
	end

	@doc """
	Returns a tuple with 2 elements:
	{notification-enabled receivers, currently disabled receivers (blocking / [thread] muting)}

	NOTE: might be called for FAKE Activities, see ActivityPub.Utils.get_notified_from_object/1
	"""
	@spec get_notified_from_activity(Activity.t(), boolean()) :: list(User.t())
	def get_notified_from_activity(activity, local_only \\ true)

	def get_notified_from_activity(%Activity{data: %{"type" => type}} = activity, local_only)
	when type in [
	"Create",
	"Like",
	"Announce",
	"Follow",
	"Move",
	"EmojiReact",
	"Flag",
	"Update"
	] do
	potential_receiver_ap_ids = get_potential_receiver_ap_ids(activity)

	potential_receivers =
	User.get_users_from_set(potential_receiver_ap_ids, local_only: local_only)

	notification_enabled_ap_ids =
	potential_receiver_ap_ids
	\|> exclude_domain_blocker_ap_ids(activity, potential_receivers)
	\|> exclude_relationship_restricted_ap_ids(activity)
	\|> exclude_thread_muter_ap_ids(activity)

	Enum.filter(potential_receivers, fn u -> u.ap_id in notification_enabled_ap_ids end)
	end

	def get_notified_from_activity(_, _local_only), do: []

	def get_notified_subscribers_from_activity(activity, local_only \\ true)

	def get_notified_subscribers_from_activity(
	%Activity{data: %{"type" => "Create"}} = activity,
	local_only
	) do
	notification_enabled_ap_ids =
	[]
	\|> Utils.maybe_notify_subscribers(activity)

	potential_receivers =
	User.get_users_from_set(notification_enabled_ap_ids, local_only: local_only)

	Enum.filter(potential_receivers, fn u -> u.ap_id in notification_enabled_ap_ids end)
	end

	def get_notified_subscribers_from_activity(_, _), do: []

	# For some activities, only notify the author of the object
	def get_potential_receiver_ap_ids(%{data: %{"type" => type, "object" => object_id}})
	when type in ~w{Like Announce EmojiReact} do
	case Object.get_cached_by_ap_id(object_id) do
	%Object{data: %{"actor" => actor}} ->
	[actor]

	_ ->
	[]
	end
	end

	def get_potential_receiver_ap_ids(%{data: %{"type" => "Follow", "object" => object_id}}) do
	[object_id]
	end

	def get_potential_receiver_ap_ids(%{data: %{"type" => "Flag", "actor" => actor}}) do
	(User.all_users_with_privilege(:reports_manage_reports)
	\|> Enum.map(fn user -> user.ap_id end)) --
	[actor]
	end

	# Update activity: notify all who repeated this
	def get_potential_receiver_ap_ids(%{data: %{"type" => "Update", "actor" => actor}} = activity) do
	with %Object{data: %{"id" => object_id}} <- Object.normalize(activity, fetch: false) do
	repeaters =
	Activity.Queries.by_type("Announce")
	\|> Activity.Queries.by_object_id(object_id)
	\|> Activity.with_joined_user_actor()
	\|> where([a, u], u.local)
	\|> select([a, u], u.ap_id)
	\|> Repo.all()

	repeaters -- [actor]
	end
	end

	def get_potential_receiver_ap_ids(activity) do
	[]
	\|> Utils.maybe_notify_to_recipients(activity)
	\|> Utils.maybe_notify_mentioned_recipients(activity)
	\|> Utils.maybe_notify_followers(activity)
	\|> Enum.uniq()
	end

	@doc "Filters out AP IDs domain-blocking and not following the activity's actor"
	def exclude_domain_blocker_ap_ids(ap_ids, activity, preloaded_users \\ [])

	def exclude_domain_blocker_ap_ids([], _activity, _preloaded_users), do: []

	def exclude_domain_blocker_ap_ids(ap_ids, %Activity{} = activity, preloaded_users) do
	activity_actor_domain = activity.actor && URI.parse(activity.actor).host

	users =
	ap_ids
	\|> Enum.map(fn ap_id ->
	Enum.find(preloaded_users, &(&1.ap_id == ap_id)) \|\|
	User.get_cached_by_ap_id(ap_id)
	end)
	\|> Enum.filter(& &1)

	domain_blocker_ap_ids = for u <- users, activity_actor_domain in u.domain_blocks, do: u.ap_id

	domain_blocker_follower_ap_ids =
	if Enum.any?(domain_blocker_ap_ids) do
	activity
	\|> Activity.user_actor()
	\|> FollowingRelationship.followers_ap_ids(domain_blocker_ap_ids)
	else
	[]
	end

	ap_ids
	\|> Kernel.--(domain_blocker_ap_ids)
	\|> Kernel.++(domain_blocker_follower_ap_ids)
	end

	@doc "Filters out AP IDs of users basing on their relationships with activity actor user"
	def exclude_relationship_restricted_ap_ids([], _activity), do: []

	def exclude_relationship_restricted_ap_ids(ap_ids, %Activity{} = activity) do
	relationship_restricted_ap_ids =
	activity
	\|> Activity.user_actor()
	\|> User.incoming_relationships_ungrouped_ap_ids([
	:block,
	:notification_mute
	])

	Enum.uniq(ap_ids) -- relationship_restricted_ap_ids
	end

	@doc "Filters out AP IDs of users who mute activity thread"
	def exclude_thread_muter_ap_ids([], _activity), do: []

	def exclude_thread_muter_ap_ids(ap_ids, %Activity{} = activity) do
	thread_muter_ap_ids = ThreadMute.muter_ap_ids(activity.data["context"])

	Enum.uniq(ap_ids) -- thread_muter_ap_ids
	end

	def skip?(activity, user, opts \\ [])

	@spec skip?(Activity.t(), User.t(), Keyword.t()) :: boolean()
	def skip?(%Activity{} = activity, %User{} = user, opts) do
	[
	:self,
	:internal,
	:invisible,
	:block_from_strangers,
	:recently_followed,
	:filtered
	]
	\|> Enum.find(&skip?(&1, activity, user, opts))
	end

	def skip?(_activity, _user, _opts), do: false

	@spec skip?(atom(), Activity.t(), User.t(), Keyword.t()) :: boolean()
	def skip?(:self, %Activity{} = activity, %User{} = user, opts) do
	cond do
	opts[:type] == "poll" -> false
	activity.data["actor"] == user.ap_id -> true
	true -> false
	end
	end

	def skip?(:internal, %Activity{} = activity, _user, _opts) do
	actor = activity.data["actor"]
	user = User.get_cached_by_ap_id(actor)
	User.internal?(user)
	end

	def skip?(:invisible, %Activity{} = activity, _user, _opts) do
	actor = activity.data["actor"]
	user = User.get_cached_by_ap_id(actor)
	User.invisible?(user)
	end

	def skip?(
	:block_from_strangers,
	%Activity{} = activity,
	%User{notification_settings: %{block_from_strangers: true}} = user,
	opts
	) do
	actor = activity.data["actor"]
	follower = User.get_cached_by_ap_id(actor)

	cond do
	opts[:type] == "poll" -> false
	user.ap_id == actor -> false
	!User.following?(user, follower) -> true
	true -> false
	end
	end

	# To do: consider defining recency in hours and checking FollowingRelationship with a single SQL
	def skip?(
	:recently_followed,
	%Activity{data: %{"type" => "Follow"}} = activity,
	%User{} = user,
	_opts
	) do
	actor = activity.data["actor"]

	Notification.for_user(user)
	\|> Enum.any?(fn
	%{activity: %{data: %{"type" => "Follow", "actor" => ^actor}}} -> true
	_ -> false
	end)
	end

	def skip?(:filtered, %{data: %{"type" => type}}, _user, _opts) when type in ["Follow", "Move"],
	do: false

	def skip?(:filtered, activity, user, _opts) do
	object = Object.normalize(activity, fetch: false)

	cond do
	is_nil(object) ->
	false

	object.data["actor"] == user.ap_id ->
	false

	- not is_nil(regex = Pleroma.Filter.compose_regex(user, :re)) ->
	+ not is_nil(regex = Pleroma.Filter.compose_regex(user, "notifications", :re)) ->
	Regex.match?(regex, object.data["content"])

	true ->
	false
	end
	end

	def skip?(_type, _activity, _user, _opts), do: false

	def mark_as_read?(activity, target_user) do
	user = Activity.user_actor(activity)
	User.mutes_user?(target_user, user) \|\| CommonAPI.thread_muted?(activity, target_user)
	end

	def for_user_and_activity(user, activity) do
	from(n in __MODULE__,
	where: n.user_id == ^user.id,
	where: n.activity_id == ^activity.id
	)
	\|> Repo.one()
	end

	@spec mark_context_as_read(User.t(), String.t()) :: {integer(), nil \| [term()]}
	def mark_context_as_read(%User{id: id}, context) do
	from(
	n in Notification,
	join: a in assoc(n, :activity),
	where: n.user_id == ^id,
	where: n.seen == false,
	where: fragment("?->>'context'", a.data) == ^context
	)
	\|> Repo.update_all(set: [seen: true])
	end

	@doc "Streams a list of notifications over websockets and web push"
	@spec stream(list(Notification.t())) :: :ok
	def stream(notifications) do
	Enum.each(notifications, fn notification ->
	Streamer.stream(["user", "user:notification"], notification)
	Push.send(notification)
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index b30b0cabe..d5f25bf69 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1861 +1,1857 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPub do
	alias Pleroma.Activity
	alias Pleroma.Activity.Ir.Topics
	alias Pleroma.Config
	alias Pleroma.Constants
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation
	alias Pleroma.Filter
	alias Pleroma.Hashtag
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Object.Fetcher
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.Upload
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.WebFinger
	alias Pleroma.Workers.BackgroundWorker
	alias Pleroma.Workers.PollWorker

	import Ecto.Query
	import Pleroma.Web.ActivityPub.Utils
	import Pleroma.Web.ActivityPub.Visibility

	require Logger
	require Pleroma.Constants

	@behaviour Pleroma.Web.ActivityPub.ActivityPub.Persisting
	@behaviour Pleroma.Web.ActivityPub.ActivityPub.Streaming

	defp get_recipients(%{"type" => "Create"} = data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	actor = Map.get(data, "actor", [])
	recipients = [to, cc, bcc, [actor]] \|> Enum.concat() \|> Enum.uniq()
	{recipients, to, cc}
	end

	defp get_recipients(data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	recipients = Enum.concat([to, cc, bcc])
	{recipients, to, cc}
	end

	defp check_actor_can_insert(%{"type" => "Delete"}), do: true
	defp check_actor_can_insert(%{"type" => "Undo"}), do: true

	defp check_actor_can_insert(%{"actor" => actor}) when is_binary(actor) do
	case User.get_cached_by_ap_id(actor) do
	%User{is_active: true} -> true
	_ -> false
	end
	end

	defp check_actor_can_insert(_), do: true

	defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
	limit = Config.get([:instance, :remote_limit])
	String.length(content) <= limit
	end

	defp check_remote_limit(_), do: true

	def increase_note_count_if_public(actor, object) do
	if public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
	end

	def decrease_note_count_if_public(actor, object) do
	if public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
	end

	def update_last_status_at_if_public(actor, object) do
	if public?(object), do: User.update_last_status_at(actor), else: {:ok, actor}
	end

	defp increase_replies_count_if_reply(%{
	"object" => %{"inReplyTo" => reply_ap_id} = object,
	"type" => "Create"
	}) do
	if public?(object) do
	Object.increase_replies_count(reply_ap_id)
	end
	end

	defp increase_replies_count_if_reply(_create_data), do: :noop

	defp increase_quotes_count_if_quote(%{
	"object" => %{"quoteUrl" => quote_ap_id} = object,
	"type" => "Create"
	}) do
	if public?(object) do
	Object.increase_quotes_count(quote_ap_id)
	end
	end

	defp increase_quotes_count_if_quote(_create_data), do: :noop

	@object_types ~w[ChatMessage Question Answer Audio Video Image Event Article Note Page]
	@impl true
	def persist(%{"type" => type} = object, meta) when type in @object_types do
	with {:ok, object} <- Object.create(object) do
	{:ok, object, meta}
	end
	end

	@impl true
	def persist(object, meta) do
	with local <- Keyword.fetch!(meta, :local),
	{recipients, _, _} <- get_recipients(object),
	{:ok, activity} <-
	Repo.insert(%Activity{
	data: object,
	local: local,
	recipients: recipients,
	actor: object["actor"]
	}),
	# TODO: add tests for expired activities, when Note type will be supported in new pipeline
	{:ok, _} <- maybe_create_activity_expiration(activity) do
	{:ok, activity, meta}
	end
	end

	@spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
	with nil <- Activity.normalize(map),
	map <- lazy_put_activity_defaults(map, fake),
	{_, true} <- {:actor_check, bypass_actor_check \|\| check_actor_can_insert(map)},
	{_, true} <- {:remote_limit_pass, check_remote_limit(map)},
	{:ok, map} <- MRF.filter(map),
	{recipients, _, _} = get_recipients(map),
	{:fake, false, map, recipients} <- {:fake, fake, map, recipients},
	{:containment, :ok} <- {:containment, Containment.contain_child(map)},
	{:ok, map, object} <- insert_full_object(map),
	{:ok, activity} <- insert_activity_with_expiration(map, local, recipients) do
	# Splice in the child object if we have one.
	activity = Maps.put_if_present(activity, :object, object)

	Pleroma.Web.RichMedia.Card.get_by_activity(activity)

	# Add local posts to search index
	if local, do: Pleroma.Search.add_to_index(activity)

	{:ok, activity}
	else
	%Activity{} = activity ->
	{:ok, activity}

	{:actor_check, _} ->
	{:error, false}

	{:containment, _} = error ->
	error

	{:error, _} = error ->
	error

	{:fake, true, map, recipients} ->
	activity = %Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients,
	id: "pleroma:fakeid"
	}

	Pleroma.Web.RichMedia.Card.get_by_activity(activity)
	{:ok, activity}

	{:remote_limit_pass, _} ->
	{:error, :remote_limit}

	{:reject, _} = e ->
	{:error, e}
	end
	end

	defp insert_activity_with_expiration(data, local, recipients) do
	struct = %Activity{
	data: data,
	local: local,
	actor: data["actor"],
	recipients: recipients
	}

	with {:ok, activity} <- Repo.insert(struct) do
	maybe_create_activity_expiration(activity)
	end
	end

	def notify_and_stream(activity) do
	{:ok, notifications} = Notification.create_notifications(activity)
	Notification.stream(notifications)

	original_activity =
	case activity do
	%{data: %{"type" => "Update"}, object: %{data: %{"id" => id}}} ->
	Activity.get_create_by_object_ap_id_with_object(id)

	_ ->
	activity
	end

	conversation = create_or_bump_conversation(original_activity, original_activity.actor)
	participations = get_participations(conversation)
	stream_out(activity)
	stream_out_participations(participations)
	end

	defp maybe_create_activity_expiration(
	%{data: %{"expires_at" => %DateTime{} = expires_at}} = activity
	) do
	with {:ok, _job} <-
	Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
	activity_id: activity.id,
	expires_at: expires_at
	}) do
	{:ok, activity}
	end
	end

	defp maybe_create_activity_expiration(activity), do: {:ok, activity}

	defp create_or_bump_conversation(activity, actor) do
	with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
	%User{} = user <- User.get_cached_by_ap_id(actor) do
	Participation.mark_as_read(user, conversation)
	{:ok, conversation}
	end
	end

	defp get_participations({:ok, conversation}) do
	conversation
	\|> Repo.preload(:participations, force: true)
	\|> Map.get(:participations)
	end

	defp get_participations(_), do: []

	def stream_out_participations(participations) do
	participations =
	participations
	\|> Repo.preload(:user)

	Streamer.stream("participation", participations)
	end

	@impl true
	def stream_out_participations(%Object{data: %{"context" => context}}, user) do
	with %Conversation{} = conversation <- Conversation.get_for_ap_id(context) do
	conversation = Repo.preload(conversation, :participations)

	last_activity_id =
	fetch_latest_direct_activity_id_for_context(conversation.ap_id, %{
	user: user,
	blocking_user: user
	})

	if last_activity_id do
	stream_out_participations(conversation.participations)
	end
	end
	end

	@impl true
	def stream_out_participations(_, _), do: :noop

	@impl true
	def stream_out(%Activity{data: %{"type" => data_type}} = activity)
	when data_type in ["Create", "Announce", "Delete", "Update"] do
	activity
	\|> Topics.get_activity_topics()
	\|> Streamer.stream(activity)
	end

	@impl true
	def stream_out(_activity) do
	:noop
	end

	@spec create(map(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def create(params, fake \\ false) do
	with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
	result
	end
	end

	defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]
	quick_insert? = Config.get([:env]) == :benchmark

	create_data =
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(create_data),
	_ <- increase_quotes_count_if_quote(create_data),
	{:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	{:ok, _actor} <- update_last_status_at_if_public(actor, activity),
	_ <- notify_and_stream(activity),
	:ok <- maybe_schedule_poll_notifications(activity),
	:ok <- maybe_handle_group_posts(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:quick_insert, true, activity} ->
	{:ok, activity}

	{:fake, true, activity} ->
	{:ok, activity}

	{:error, message} ->
	Repo.rollback(message)
	end
	end

	defp maybe_schedule_poll_notifications(activity) do
	PollWorker.schedule_poll_end(activity)
	:ok
	end

	@spec listen(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def listen(%{to: to, actor: actor, context: context, object: object} = params) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]

	listen_data =
	make_listen_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(listen_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec unfollow(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| nil \| {:error, any()}
	def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
	result
	end
	end

	defp do_unfollow(follower, followed, activity_id, local) do
	with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
	unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
	{:ok, activity} <- insert(unfollow_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	nil -> nil
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec flag(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def flag(params) do
	with {:ok, result} <- Repo.transaction(fn -> do_flag(params) end) do
	result
	end
	end

	defp do_flag(
	%{
	actor: actor,
	context: _context,
	account: account,
	statuses: statuses,
	content: content
	} = params
	) do
	# only accept false as false value
	local = !(params[:local] == false)
	forward = !(params[:forward] == false)

	additional = params[:additional] \|\| %{}

	additional =
	if forward do
	Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
	else
	Map.merge(additional, %{"to" => [], "cc" => []})
	end

	with flag_data <- make_flag_data(params, additional),
	{:ok, activity} <- insert(flag_data, local),
	{:ok, stripped_activity} <- strip_report_status_data(activity),
	_ <- notify_and_stream(activity),
	:ok <-
	maybe_federate(stripped_activity) do
	User.all_users_with_privilege(:reports_manage_reports)
	\|> Enum.filter(fn user -> user.ap_id != actor end)
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn privileged_user ->
	privileged_user
	\|> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, activity}
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def move(%User{} = origin, %User{} = target, local \\ true) do
	params = %{
	"type" => "Move",
	"actor" => origin.ap_id,
	"object" => origin.ap_id,
	"target" => target.ap_id,
	"to" => [origin.follower_address]
	}

	with true <- origin.ap_id in target.also_known_as,
	{:ok, activity} <- insert(params, local),
	_ <- notify_and_stream(activity) do
	maybe_federate(activity)

	BackgroundWorker.enqueue("move_following", %{
	"origin_id" => origin.id,
	"target_id" => target.id
	})

	{:ok, activity}
	else
	false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
	err -> err
	end
	end

	def fetch_activities_for_context_query(context, opts) do
	public = [Constants.as_public()]

	recipients =
	if opts[:user],
	do: [opts[:user].ap_id \| User.following(opts[:user])] ++ public,
	else: public

	from(activity in Activity)
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> restrict_unauthenticated(opts[:user])
	\|> restrict_blocked(opts)
	\|> restrict_blockers_visibility(opts)
	\|> restrict_recipients(recipients, opts[:user])
	\|> restrict_filtered(opts)
	\|> where(
	[activity],
	fragment(
	"?->>'type' = ? and ?->>'context' = ?",
	activity.data,
	"Create",
	activity.data,
	^context
	)
	)
	\|> exclude_poll_votes(opts)
	\|> exclude_id(opts)
	\|> order_by([activity], desc: activity.id)
	end

	@spec fetch_activities_for_context(String.t(), keyword() \| map()) :: [Activity.t()]
	def fetch_activities_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(opts)
	\|> Repo.all()
	end

	@spec fetch_latest_direct_activity_id_for_context(String.t(), keyword() \| map()) ::
	Ecto.UUID.t() \| nil
	def fetch_latest_direct_activity_id_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(Map.merge(%{skip_preload: true}, opts))
	\|> restrict_visibility(%{visibility: "direct"})
	\|> limit(1)
	\|> select([a], a.id)
	\|> Repo.one()
	end

	defp fetch_paginated_optimized(query, opts, pagination) do
	# Note: tag-filtering funcs may apply "ORDER BY objects.id DESC",
	# and extra sorting on "activities.id DESC NULLS LAST" would worse the query plan
	opts = Map.put(opts, :skip_extra_order, true)

	Pagination.fetch_paginated(query, opts, pagination)
	end

	def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
	list_memberships = Pleroma.List.memberships(opts[:user])

	fetch_activities_query(recipients ++ list_memberships, opts)
	\|> fetch_paginated_optimized(opts, pagination)
	\|> Enum.reverse()
	\|> maybe_update_cc(list_memberships, opts[:user])
	end

	@spec fetch_public_or_unlisted_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_or_unlisted_activities(opts \\ %{}, pagination \\ :keyset) do
	includes_local_public = Map.get(opts, :includes_local_public, false)

	opts = Map.delete(opts, :user)

	intended_recipients =
	if includes_local_public do
	[Constants.as_public(), as_local_public()]
	else
	[Constants.as_public()]
	end

	intended_recipients
	\|> fetch_activities_query(opts)
	\|> restrict_unlisted(opts)
	\|> fetch_paginated_optimized(opts, pagination)
	end

	@spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
	opts
	\|> Map.put(:restrict_unlisted, true)
	\|> fetch_public_or_unlisted_activities(pagination)
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp restrict_visibility(query, %{visibility: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	from(
	a in query,
	where:
	fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not restrict visibility to #{visibility}")
	end
	end

	defp restrict_visibility(query, %{visibility: visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
	)
	end

	defp restrict_visibility(_query, %{visibility: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not restrict visibility to #{visibility}")
	end

	defp restrict_visibility(query, _visibility), do: query

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ?",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility not in [nil \| @valid_visibilities] do
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end

	defp exclude_visibility(query, _visibility), do: query

	defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
	do: query

	defp restrict_thread_visibility(query, %{user: %User{skip_thread_containment: true}}, _),
	do: query

	defp restrict_thread_visibility(query, %{user: %User{ap_id: ap_id}}, _) do
	local_public = as_local_public()

	from(
	a in query,
	where: fragment("thread_visibility(?, (?)->>'id', ?) = true", ^ap_id, a.data, ^local_public)
	)
	end

	defp restrict_thread_visibility(query, _, _), do: query

	def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put(:user, reading_user)
	\|> Map.put(:actor_id, user.ap_id)

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params)
	\|> Enum.reverse()
	end

	def fetch_user_activities(user, reading_user, params \\ %{})

	def fetch_user_activities(user, reading_user, %{total: true} = params) do
	result = fetch_activities_for_user(user, reading_user, params)

	Keyword.put(result, :items, Enum.reverse(result[:items]))
	end

	def fetch_user_activities(user, reading_user, params) do
	user
	\|> fetch_activities_for_user(reading_user, params)
	\|> Enum.reverse()
	end

	defp fetch_activities_for_user(user, reading_user, params) do
	params =
	params
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:user, reading_user)
	\|> Map.put(:actor_id, user.ap_id)
	\|> Map.put(:pinned_object_ids, Map.keys(user.pinned_objects))

	params =
	if User.blocks?(reading_user, user) do
	params
	else
	params
	\|> Map.put(:blocking_user, reading_user)
	\|> Map.put(:muting_user, reading_user)
	end

	pagination_type = Map.get(params, :pagination_type) \|\| :keyset

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params, pagination_type)
	end

	def fetch_statuses(reading_user, %{total: true} = params) do
	result = fetch_activities_for_reading_user(reading_user, params)
	Keyword.put(result, :items, Enum.reverse(result[:items]))
	end

	def fetch_statuses(reading_user, params) do
	reading_user
	\|> fetch_activities_for_reading_user(params)
	\|> Enum.reverse()
	end

	defp fetch_activities_for_reading_user(reading_user, params) do
	params = Map.put(params, :type, ["Create", "Announce"])

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params, :offset)
	end

	defp user_activities_recipients(%{godmode: true}), do: []

	defp user_activities_recipients(%{reading_user: reading_user}) do
	if not is_nil(reading_user) and reading_user.local do
	[
	Constants.as_public(),
	as_local_public(),
	reading_user.ap_id \| User.following(reading_user)
	]
	else
	[Constants.as_public()]
	end
	end

	defp restrict_announce_object_actor(_query, %{announce_filtering_user: _, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_announce_object_actor(query, %{announce_filtering_user: %{ap_id: actor}}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'type' != ? or ?->>'actor' != ?",
	activity.data,
	"Announce",
	object.data,
	^actor
	)
	)
	end

	defp restrict_announce_object_actor(query, _), do: query

	defp restrict_since(query, %{since_id: ""}), do: query

	defp restrict_since(query, %{since_id: since_id}) do
	from(activity in query, where: activity.id > ^since_id)
	end

	defp restrict_since(query, _), do: query

	defp restrict_embedded_tag_all(_query, %{tag_all: _tag_all, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_embedded_tag_all(query, %{tag_all: [_ \| _] = tag_all}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
	)
	end

	defp restrict_embedded_tag_all(query, %{tag_all: tag}) when is_binary(tag) do
	restrict_embedded_tag_any(query, %{tag: tag})
	end

	defp restrict_embedded_tag_all(query, _), do: query

	defp restrict_embedded_tag_any(_query, %{tag: _tag, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_embedded_tag_any(query, %{tag: [_ \| _] = tag_any}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?\| (?)", object.data, ^tag_any)
	)
	end

	defp restrict_embedded_tag_any(query, %{tag: tag}) when is_binary(tag) do
	restrict_embedded_tag_any(query, %{tag: [tag]})
	end

	defp restrict_embedded_tag_any(query, _), do: query

	defp restrict_embedded_tag_reject_any(_query, %{tag_reject: _tag_reject, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_embedded_tag_reject_any(query, %{tag_reject: [_ \| _] = tag_reject}) do
	from(
	[_activity, object] in query,
	where: fragment("not (?)->'tag' \\?\| (?)", object.data, ^tag_reject)
	)
	end

	defp restrict_embedded_tag_reject_any(query, %{tag_reject: tag_reject})
	when is_binary(tag_reject) do
	restrict_embedded_tag_reject_any(query, %{tag_reject: [tag_reject]})
	end

	defp restrict_embedded_tag_reject_any(query, _), do: query

	defp object_ids_query_for_tags(tags) do
	from(hto in "hashtags_objects")
	\|> join(:inner, [hto], ht in Pleroma.Hashtag, on: hto.hashtag_id == ht.id)
	\|> where([hto, ht], ht.name in ^tags)
	\|> select([hto], hto.object_id)
	\|> distinct([hto], true)
	end

	defp restrict_hashtag_all(_query, %{tag_all: _tag, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_hashtag_all(query, %{tag_all: [single_tag]}) do
	restrict_hashtag_any(query, %{tag: single_tag})
	end

	defp restrict_hashtag_all(query, %{tag_all: [_ \| _] = tags}) do
	from(
	[_activity, object] in query,
	where:
	fragment(
	"""
	(SELECT array_agg(hashtags.name) FROM hashtags JOIN hashtags_objects
	ON hashtags_objects.hashtag_id = hashtags.id WHERE hashtags.name = ANY(?)
	AND hashtags_objects.object_id = ?) @> ?
	""",
	^tags,
	object.id,
	^tags
	)
	)
	end

	defp restrict_hashtag_all(query, %{tag_all: tag}) when is_binary(tag) do
	restrict_hashtag_all(query, %{tag_all: [tag]})
	end

	defp restrict_hashtag_all(query, _), do: query

	defp restrict_hashtag_any(_query, %{tag: _tag, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_hashtag_any(query, %{tag: [_ \| _] = tags}) do
	hashtag_ids =
	from(ht in Hashtag, where: ht.name in ^tags, select: ht.id)
	\|> Repo.all()

	# Note: NO extra ordering should be done on "activities.id desc nulls last" for optimal plan
	from(
	[_activity, object] in query,
	join: hto in "hashtags_objects",
	on: hto.object_id == object.id,
	where: hto.hashtag_id in ^hashtag_ids,
	distinct: [desc: object.id],
	order_by: [desc: object.id]
	)
	end

	defp restrict_hashtag_any(query, %{tag: tag}) when is_binary(tag) do
	restrict_hashtag_any(query, %{tag: [tag]})
	end

	defp restrict_hashtag_any(query, _), do: query

	defp restrict_hashtag_reject_any(_query, %{tag_reject: _tag_reject, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_hashtag_reject_any(query, %{tag_reject: [_ \| _] = tags_reject}) do
	from(
	[_activity, object] in query,
	where: object.id not in subquery(object_ids_query_for_tags(tags_reject))
	)
	end

	defp restrict_hashtag_reject_any(query, %{tag_reject: tag_reject}) when is_binary(tag_reject) do
	restrict_hashtag_reject_any(query, %{tag_reject: [tag_reject]})
	end

	defp restrict_hashtag_reject_any(query, _), do: query

	defp raise_on_missing_preload do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_recipients(query, [], _user), do: query

	defp restrict_recipients(query, recipients, nil) do
	from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
	end

	defp restrict_recipients(query, recipients, user) do
	from(
	activity in query,
	where: fragment("? && ?", ^recipients, activity.recipients),
	or_where: activity.actor == ^user.ap_id
	)
	end

	defp restrict_local(query, %{local_only: true}) do
	from(activity in query, where: activity.local == true)
	end

	defp restrict_local(query, _), do: query

	defp restrict_remote(query, %{remote: true}) do
	from(activity in query, where: activity.local == false)
	end

	defp restrict_remote(query, _), do: query

	defp restrict_actor(query, %{actor_id: actor_id}) do
	from(activity in query, where: activity.actor == ^actor_id)
	end

	defp restrict_actor(query, _), do: query

	defp restrict_type(query, %{type: type}) when is_binary(type) do
	from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
	end

	defp restrict_type(query, %{type: type}) do
	from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
	end

	defp restrict_type(query, _), do: query

	defp restrict_state(query, %{state: state}) do
	from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
	end

	defp restrict_state(query, _), do: query

	defp restrict_favorited_by(query, %{favorited_by: ap_id}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
	)
	end

	defp restrict_favorited_by(query, _), do: query

	defp restrict_media(_query, %{only_media: _val, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_media(query, %{only_media: true}) do
	from(
	[activity, object] in query,
	where: fragment("(?)->>'type' = ?", activity.data, "Create"),
	where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

	defp restrict_replies(query, %{exclude_replies: true}) do
	from(
	[activity, object] in query,
	where:
	fragment("?->>'inReplyTo' is null or ?->>'type' = 'Announce'", object.data, activity.data)
	)
	end

	defp restrict_replies(query, %{
	reply_filtering_user: %User{} = user,
	reply_visibility: "self"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'inReplyTo' is null OR ? = ANY(?)",
	object.data,
	^user.ap_id,
	activity.recipients
	)
	)
	end

	defp restrict_replies(query, %{
	reply_filtering_user: %User{} = user,
	reply_visibility: "following"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"""
	?->>'type' != 'Create' -- This isn't a Create
	OR ?->>'inReplyTo' is null -- this isn't a reply
	OR ? && array_remove(?, ?) -- The recipient is us or one of our friends,
	-- unless they are the author (because authors
	-- are also part of the recipients). This leads
	-- to a bug that self-replies by friends won't
	-- show up.
	OR ? = ? -- The actor is us
	""",
	activity.data,
	object.data,
	^[user.ap_id \| User.get_cached_user_friends_ap_ids(user)],
	activity.recipients,
	activity.actor,
	activity.actor,
	^user.ap_id
	)
	)
	end

	defp restrict_replies(query, _), do: query

	defp restrict_reblogs(query, %{exclude_reblogs: true}) do
	from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
	end

	defp restrict_reblogs(query, _), do: query

	defp restrict_muted(query, %{with_muted: true}), do: query

	defp restrict_muted(query, %{muting_user: %User{} = user} = opts) do
	mutes = opts[:muted_users_ap_ids] \|\| User.muted_users_ap_ids(user)

	query =
	from([activity] in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
	where:
	fragment(
	"not (?->'to' \\?\| ?) or ? = ?",
	activity.data,
	^mutes,
	activity.actor,
	^user.ap_id
	)
	)

	unless opts[:skip_preload] do
	from([thread_mute: tm] in query, where: is_nil(tm.user_id))
	else
	query
	end
	end

	defp restrict_muted(query, _), do: query

	defp restrict_blocked(query, %{blocking_user: %User{} = user} = opts) do
	blocked_ap_ids = opts[:blocked_users_ap_ids] \|\| User.blocked_users_ap_ids(user)
	domain_blocks = user.domain_blocks \|\| []

	following_ap_ids = User.get_friends_ap_ids(user)

	query =
	if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)

	from(
	[activity, object: o] in query,
	# You don't block the author
	where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),

	# You don't block any recipients, and didn't author the post
	where:
	fragment(
	"((not (? && ?)) or ? = ?)",
	activity.recipients,
	^blocked_ap_ids,
	activity.actor,
	^user.ap_id
	),

	# You don't block the domain of any recipients, and didn't author the post
	where:
	fragment(
	"(recipients_contain_blocked_domains(?, ?) = false) or ? = ?",
	activity.recipients,
	^domain_blocks,
	activity.actor,
	^user.ap_id
	),

	# It's not a boost of a user you block
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocked_ap_ids
	),

	# You don't block the author's domain, and also don't follow the author
	where:
	fragment(
	"(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
	activity.actor,
	^domain_blocks,
	activity.actor,
	^following_ap_ids
	),

	# Same as above, but checks the Object
	where:
	fragment(
	"(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
	o.data,
	^domain_blocks,
	o.data,
	^following_ap_ids
	)
	)
	end

	defp restrict_blocked(query, _), do: query

	defp restrict_blockers_visibility(query, %{blocking_user: %User{} = user}) do
	if Config.get([:activitypub, :blockers_visible]) == true do
	query
	else
	blocker_ap_ids = User.incoming_relationships_ungrouped_ap_ids(user, [:block])

	from(
	activity in query,
	# The author doesn't block you
	where: fragment("not (? = ANY(?))", activity.actor, ^blocker_ap_ids),

	# It's not a boost of a user that blocks you
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocker_ap_ids
	)
	)
	end
	end

	defp restrict_blockers_visibility(query, _), do: query

	defp restrict_unlisted(query, %{restrict_unlisted: true}) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^[Constants.as_public()]
	)
	)
	end

	defp restrict_unlisted(query, _), do: query

	defp restrict_pinned(query, %{pinned: true, pinned_object_ids: ids}) do
	from(
	[activity, object: o] in query,
	where:
	fragment(
	"(?)->>'type' = 'Create' and associated_object_id((?)) = any (?)",
	activity.data,
	activity.data,
	^ids
	)
	)
	end

	defp restrict_pinned(query, _), do: query

	defp restrict_muted_reblogs(query, %{muting_user: %User{} = user} = opts) do
	muted_reblogs = opts[:reblog_muted_users_ap_ids] \|\| User.reblog_muted_users_ap_ids(user)

	from(
	activity in query,
	where:
	fragment(
	"not ( ?->>'type' = 'Announce' and ? = ANY(?))",
	activity.data,
	activity.actor,
	^muted_reblogs
	)
	)
	end

	defp restrict_muted_reblogs(query, _), do: query

	defp restrict_instance(query, %{instance: instance}) when is_binary(instance) do
	from(
	activity in query,
	where: fragment("split_part(actor::text, '/'::text, 3) = ?", ^instance)
	)
	end

	defp restrict_instance(query, _), do: query

	- defp restrict_filtered(query, %{user: %User{} = user}) do
	- case Filter.compose_regex(user) do
	+ defp restrict_filtered(query, %{phrase_filtering_user: %User{} = user}) do
	+ case Filter.compose_regex(user, "home") do
	nil ->
	query

	regex ->
	from([activity, object] in query,
	where:
	fragment("not(?->>'content' ~* ?)", object.data, ^regex) or
	activity.actor == ^user.ap_id
	)
	end
	end

	- defp restrict_filtered(query, %{blocking_user: %User{} = user}) do
	- restrict_filtered(query, %{user: user})
	- end
	-
	defp restrict_filtered(query, _), do: query

	defp restrict_unauthenticated(query, nil) do
	local = Config.restrict_unauthenticated_access?(:activities, :local)
	remote = Config.restrict_unauthenticated_access?(:activities, :remote)

	cond do
	local and remote ->
	from(activity in query, where: false)

	local ->
	from(activity in query, where: activity.local == false)

	remote ->
	from(activity in query, where: activity.local == true)

	true ->
	query
	end
	end

	defp restrict_unauthenticated(query, _), do: query

	defp restrict_quote_url(query, %{quote_url: quote_url}) do
	from([_activity, object] in query,
	where: fragment("(?)->'quoteUrl' = ?", object.data, ^quote_url)
	)
	end

	defp restrict_quote_url(query, _), do: query

	defp restrict_rule(query, %{rule_id: rule_id}) do
	from(
	activity in query,
	where: fragment("(?)->'rules' \\? (?)", activity.data, ^rule_id)
	)
	end

	defp restrict_rule(query, _), do: query

	defp exclude_poll_votes(query, %{include_poll_votes: true}), do: query

	defp exclude_poll_votes(query, _) do
	if has_named_binding?(query, :object) do
	from([activity, object: o] in query,
	where: fragment("not(?->>'type' = ?)", o.data, "Answer")
	)
	else
	query
	end
	end

	defp exclude_chat_messages(query, %{include_chat_messages: true}), do: query

	defp exclude_chat_messages(query, _) do
	if has_named_binding?(query, :object) do
	from([activity, object: o] in query,
	where: fragment("not(?->>'type' = ?)", o.data, "ChatMessage")
	)
	else
	query
	end
	end

	defp exclude_invisible_actors(query, %{type: "Flag"}), do: query
	defp exclude_invisible_actors(query, %{invisible_actors: true}), do: query

	defp exclude_invisible_actors(query, _opts) do
	query
	\|> join(:inner, [activity], u in User,
	as: :u,
	on: activity.actor == u.ap_id and u.invisible == false
	)
	end

	defp exclude_id(query, %{exclude_id: id}) when is_binary(id) do
	from(activity in query, where: activity.id != ^id)
	end

	defp exclude_id(query, _), do: query

	defp maybe_preload_objects(query, %{skip_preload: true}), do: query

	defp maybe_preload_objects(query, _) do
	query
	\|> Activity.with_preloaded_object()
	end

	defp maybe_preload_bookmarks(query, %{skip_preload: true}), do: query

	defp maybe_preload_bookmarks(query, opts) do
	query
	\|> Activity.with_preloaded_bookmark(opts[:user])
	end

	defp maybe_preload_report_notes(query, %{preload_report_notes: true}) do
	query
	\|> Activity.with_preloaded_report_notes()
	end

	defp maybe_preload_report_notes(query, _), do: query

	defp maybe_set_thread_muted_field(query, %{skip_preload: true}), do: query

	defp maybe_set_thread_muted_field(query, opts) do
	query
	\|> Activity.with_set_thread_muted_field(opts[:muting_user] \|\| opts[:user])
	end

	defp maybe_order(query, %{order: :desc}) do
	query
	\|> order_by(desc: :id)
	end

	defp maybe_order(query, %{order: :asc}) do
	query
	\|> order_by(asc: :id)
	end

	defp maybe_order(query, _), do: query

	defp normalize_fetch_activities_query_opts(opts) do
	Enum.reduce([:tag, :tag_all, :tag_reject], opts, fn key, opts ->
	case opts[key] do
	value when is_bitstring(value) ->
	Map.put(opts, key, Hashtag.normalize_name(value))

	value when is_list(value) ->
	normalized_value =
	value
	\|> Enum.map(&Hashtag.normalize_name/1)
	\|> Enum.uniq()

	Map.put(opts, key, normalized_value)

	_ ->
	opts
	end
	end)
	end

	defp fetch_activities_query_ap_ids_ops(opts) do
	source_user = opts[:muting_user]
	ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []

	ap_id_relationships =
	if opts[:blocking_user] && opts[:blocking_user] == source_user do
	[:block \| ap_id_relationships]
	else
	ap_id_relationships
	end

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)

	restrict_blocked_opts = Map.merge(%{blocked_users_ap_ids: preloaded_ap_ids[:block]}, opts)
	restrict_muted_opts = Map.merge(%{muted_users_ap_ids: preloaded_ap_ids[:mute]}, opts)

	restrict_muted_reblogs_opts =
	Map.merge(%{reblog_muted_users_ap_ids: preloaded_ap_ids[:reblog_mute]}, opts)

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
	end

	def fetch_activities_query(recipients, opts \\ %{}) do
	opts = normalize_fetch_activities_query_opts(opts)

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
	fetch_activities_query_ap_ids_ops(opts)

	config = %{
	skip_thread_containment: Config.get([:instance, :skip_thread_containment])
	}

	query =
	Activity
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_preload_report_notes(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> maybe_order(opts)
	\|> restrict_recipients(recipients, opts[:user])
	\|> restrict_replies(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_remote(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_state(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(restrict_blocked_opts)
	\|> restrict_blockers_visibility(opts)
	\|> restrict_muted(restrict_muted_opts)
	\|> restrict_filtered(opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_thread_visibility(opts, config)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	\|> restrict_muted_reblogs(restrict_muted_reblogs_opts)
	\|> restrict_instance(opts)
	\|> restrict_announce_object_actor(opts)
	\|> restrict_filtered(opts)
	\|> restrict_rule(opts)
	\|> restrict_quote_url(opts)
	\|> maybe_restrict_deactivated_users(opts)
	\|> exclude_poll_votes(opts)
	\|> exclude_chat_messages(opts)
	\|> exclude_invisible_actors(opts)
	\|> exclude_visibility(opts)

	if Config.feature_enabled?(:improved_hashtag_timeline) do
	query
	\|> restrict_hashtag_any(opts)
	\|> restrict_hashtag_all(opts)
	\|> restrict_hashtag_reject_any(opts)
	else
	query
	\|> restrict_embedded_tag_any(opts)
	\|> restrict_embedded_tag_all(opts)
	\|> restrict_embedded_tag_reject_any(opts)
	end
	end

	@doc """
	Fetch favorites activities of user with order by sort adds to favorites
	"""
	@spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
	def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Like")
	\|> Activity.with_joined_object()
	\|> Object.with_joined_activity()
	\|> select([like, object, activity], %{activity \| object: object, pagination_id: like.id})
	\|> order_by([like, _, _], desc_nulls_last: like.id)
	\|> Pagination.fetch_paginated(
	Map.merge(params, %{skip_order: true}),
	pagination
	)
	end

	defp maybe_update_cc(activities, [_ \| _] = list_memberships, %User{ap_id: user_ap_id}) do
	Enum.map(activities, fn
	%{data: %{"bcc" => [_ \| _] = bcc}} = activity ->
	if Enum.any?(bcc, &(&1 in list_memberships)) do
	update_in(activity.data["cc"], &[user_ap_id \| &1])
	else
	activity
	end

	activity ->
	activity
	end)
	end

	defp maybe_update_cc(activities, _, _), do: activities

	defp fetch_activities_bounded_query(query, recipients, recipients_with_public) do
	from(activity in query,
	where:
	fragment("? && ?", activity.recipients, ^recipients) or
	(fragment("? && ?", activity.recipients, ^recipients_with_public) and
	^Constants.as_public() in activity.recipients)
	)
	end

	def fetch_activities_bounded(
	recipients,
	recipients_with_public,
	opts \\ %{},
	pagination \\ :keyset
	) do
	fetch_activities_query([], opts)
	\|> fetch_activities_bounded_query(recipients, recipients_with_public)
	\|> Pagination.fetch_paginated(opts, pagination)
	\|> Enum.reverse()
	end

	@spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} \| {:error, any()}
	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(sanitize_upload_file(file), opts) do
	obj_data = Maps.put_if_present(data, "actor", opts[:actor])

	Repo.insert(%Object{data: obj_data})
	end
	end

	defp sanitize_upload_file(%Plug.Upload{filename: filename} = upload) when is_binary(filename) do
	%Plug.Upload{
	upload
	\| filename: Path.basename(filename)
	}
	end

	defp sanitize_upload_file(upload), do: upload

	@spec get_actor_url(any()) :: binary() \| nil
	defp get_actor_url(url) when is_binary(url), do: url
	defp get_actor_url(%{"href" => href}) when is_binary(href), do: href

	defp get_actor_url(url) when is_list(url) do
	url
	\|> List.first()
	\|> get_actor_url()
	end

	defp get_actor_url(_url), do: nil

	defp normalize_image(%{"url" => url}) do
	%{
	"type" => "Image",
	"url" => [%{"href" => url}]
	}
	end

	defp normalize_image(urls) when is_list(urls), do: urls \|> List.first() \|> normalize_image()
	defp normalize_image(_), do: nil

	defp object_to_user_data(data, additional) do
	fields =
	data
	\|> Map.get("attachment", [])
	\|> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
	\|> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)

	emojis =
	data
	\|> Map.get("tag", [])
	\|> Enum.filter(fn
	%{"type" => "Emoji"} -> true
	_ -> false
	end)
	\|> Map.new(fn %{"icon" => %{"url" => url}, "name" => name} ->
	{String.trim(name, ":"), url}
	end)

	is_locked = data["manuallyApprovesFollowers"] \|\| false
	capabilities = data["capabilities"] \|\| %{}
	accepts_chat_messages = capabilities["acceptsChatMessages"]
	data = Transmogrifier.maybe_fix_user_object(data)
	is_discoverable = data["discoverable"] \|\| false
	invisible = data["invisible"] \|\| false
	actor_type = data["type"] \|\| "Person"

	featured_address = data["featured"]
	{:ok, pinned_objects} = fetch_and_prepare_featured_from_ap_id(featured_address)

	public_key =
	if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
	data["publicKey"]["publicKeyPem"]
	end

	shared_inbox =
	if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
	data["endpoints"]["sharedInbox"]
	end

	birthday =
	if is_binary(data["vcard:bday"]) do
	case Date.from_iso8601(data["vcard:bday"]) do
	{:ok, date} -> date
	{:error, _} -> nil
	end
	end

	show_birthday = !!birthday

	# if WebFinger request was already done, we probably have acct, otherwise
	# we request WebFinger here
	nickname = additional[:nickname_from_acct] \|\| generate_nickname(data)

	%{
	ap_id: data["id"],
	uri: get_actor_url(data["url"]),
	banner: normalize_image(data["image"]),
	fields: fields,
	emoji: emojis,
	is_locked: is_locked,
	is_discoverable: is_discoverable,
	invisible: invisible,
	avatar: normalize_image(data["icon"]),
	name: data["name"],
	follower_address: data["followers"],
	following_address: data["following"],
	featured_address: featured_address,
	bio: data["summary"] \|\| "",
	actor_type: actor_type,
	also_known_as: Map.get(data, "alsoKnownAs", []),
	public_key: public_key,
	inbox: data["inbox"],
	shared_inbox: shared_inbox,
	accepts_chat_messages: accepts_chat_messages,
	birthday: birthday,
	show_birthday: show_birthday,
	pinned_objects: pinned_objects,
	nickname: nickname
	}
	end

	defp generate_nickname(%{"preferredUsername" => username} = data) when is_binary(username) do
	generated = "#{username}@#{URI.parse(data["id"]).host}"

	if Config.get([WebFinger, :update_nickname_on_user_fetch]) do
	case WebFinger.finger(generated) do
	{:ok, %{"subject" => "acct:" <> acct}} -> acct
	_ -> generated
	end
	else
	generated
	end
	end

	# nickname can be nil because of virtual actors
	defp generate_nickname(_), do: nil

	def fetch_follow_information_for_user(user) do
	with {:ok, following_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
	{:ok, hide_follows} <- collection_private(following_data),
	{:ok, followers_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
	{:ok, hide_followers} <- collection_private(followers_data) do
	{:ok,
	%{
	hide_follows: hide_follows,
	follower_count: normalize_counter(followers_data["totalItems"]),
	following_count: normalize_counter(following_data["totalItems"]),
	hide_followers: hide_followers
	}}
	else
	{:error, _} = e -> e
	end
	end

	defp normalize_counter(counter) when is_integer(counter), do: counter
	defp normalize_counter(_), do: 0

	def maybe_update_follow_information(user_data) do
	with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
	{_, true} <- {:user_type_check, user_data[:type] in ["Person", "Service"]},
	{_, true} <-
	{:collections_available,
	!!(user_data[:following_address] && user_data[:follower_address])},
	{:ok, info} <-
	fetch_follow_information_for_user(user_data) do
	info = Map.merge(user_data[:info] \|\| %{}, info)

	user_data
	\|> Map.put(:info, info)
	else
	{:user_type_check, false} ->
	user_data

	{:collections_available, false} ->
	user_data

	{:enabled, false} ->
	user_data

	e ->
	Logger.error(
	"Follower/Following counter update for #{user_data.ap_id} failed.\n" <> inspect(e)
	)

	user_data
	end
	end

	defp collection_private(%{"first" => %{"type" => type}})
	when type in ["CollectionPage", "OrderedCollectionPage"],
	do: {:ok, false}

	defp collection_private(%{"first" => first}) do
	with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
	Fetcher.fetch_and_contain_remote_object_from_id(first) do
	{:ok, false}
	else
	{:error, _} -> {:ok, true}
	end
	end

	defp collection_private(_data), do: {:ok, true}

	def user_data_from_user_object(data, additional \\ []) do
	with {:ok, data} <- MRF.filter(data) do
	{:ok, object_to_user_data(data, additional)}
	else
	e -> {:error, e}
	end
	end

	defp fetch_and_prepare_user_from_ap_id(ap_id, additional) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
	{:ok, data} <- user_data_from_user_object(data, additional) do
	{:ok, maybe_update_follow_information(data)}
	else
	# If this has been deleted, only log a debug and not an error
	{:error, "Object has been deleted" = e} ->
	Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}

	{:error, {:reject, reason} = e} ->
	Logger.info("Rejected user #{ap_id}: #{inspect(reason)}")
	{:error, e}

	{:error, e} ->
	Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}
	end
	end

	def maybe_handle_clashing_nickname(data) do
	with nickname when is_binary(nickname) <- data[:nickname],
	%User{} = old_user <- User.get_by_nickname(nickname),
	{_, false} <- {:ap_id_comparison, data[:ap_id] == old_user.ap_id} do
	Logger.info(
	"Found an old user for #{nickname}, the old ap id is #{old_user.ap_id}, new one is #{data[:ap_id]}, renaming."
	)

	old_user
	\|> User.remote_user_changeset(%{nickname: "#{old_user.id}.#{old_user.nickname}"})
	\|> User.update_and_set_cache()
	else
	{:ap_id_comparison, true} ->
	Logger.info(
	"Found an old user for #{data[:nickname]}, but the ap id #{data[:ap_id]} is the same as the new user. Race condition? Not changing anything."
	)

	_ ->
	nil
	end
	end

	def pin_data_from_featured_collection(%{
	"type" => type,
	"orderedItems" => objects
	})
	when type in ["OrderedCollection", "Collection"] do
	Map.new(objects, fn
	%{"id" => object_ap_id} -> {object_ap_id, NaiveDateTime.utc_now()}
	object_ap_id when is_binary(object_ap_id) -> {object_ap_id, NaiveDateTime.utc_now()}
	end)
	end

	def pin_data_from_featured_collection(obj) do
	Logger.error("Could not parse featured collection #{inspect(obj)}")
	%{}
	end

	def fetch_and_prepare_featured_from_ap_id(nil) do
	{:ok, %{}}
	end

	def fetch_and_prepare_featured_from_ap_id(ap_id) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id) do
	{:ok, pin_data_from_featured_collection(data)}
	else
	e ->
	Logger.error("Could not decode featured collection at fetch #{ap_id}, #{inspect(e)}")
	{:ok, %{}}
	end
	end

	def enqueue_pin_fetches(%{pinned_objects: pins}) do
	# enqueue a task to fetch all pinned objects
	Enum.each(pins, fn {ap_id, _} ->
	if is_nil(Object.get_cached_by_ap_id(ap_id)) do
	Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
	"id" => ap_id,
	"depth" => 1
	})
	end
	end)
	end

	def enqueue_pin_fetches(_), do: nil

	def make_user_from_ap_id(ap_id, additional \\ []) do
	user = User.get_cached_by_ap_id(ap_id)

	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id, additional) do
	enqueue_pin_fetches(data)

	if user do
	user
	\|> User.remote_user_changeset(data)
	\|> User.update_and_set_cache()
	else
	maybe_handle_clashing_nickname(data)

	data
	\|> User.remote_user_changeset()
	\|> Repo.insert()
	\|> User.set_cache()
	end
	end
	end

	def make_user_from_nickname(nickname) do
	with {:ok, %{"ap_id" => ap_id, "subject" => "acct:" <> acct}} when not is_nil(ap_id) <-
	WebFinger.finger(nickname) do
	make_user_from_ap_id(ap_id, nickname_from_acct: acct)
	else
	_e -> {:error, "No AP id in WebFinger"}
	end
	end

	# filter out broken threads
	defp contain_broken_threads(%Activity{} = activity, %User{} = user) do
	entire_thread_visible_for_user?(activity, user)
	end

	# do post-processing on a specific activity
	def contain_activity(%Activity{} = activity, %User{} = user) do
	contain_broken_threads(activity, user)
	end

	def fetch_direct_messages_query do
	Activity
	\|> restrict_type(%{type: "Create"})
	\|> restrict_visibility(%{visibility: "direct"})
	\|> order_by([activity], asc: activity.id)
	end

	defp maybe_restrict_deactivated_users(activity, %{type: "Flag"}), do: activity

	defp maybe_restrict_deactivated_users(activity, _opts),
	do: Activity.restrict_deactivated_users(activity)
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex b/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
	index 293c61b41..d4ddb9a66 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
	@@ -1,210 +1,211 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.TimelineController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [add_link_headers: 2, add_link_headers: 3]

	alias Pleroma.Config
	alias Pleroma.Pagination
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.RateLimiter

	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(:skip_public_check when action in [:public, :hashtag])

	# TODO: Replace with a macro when there is a Phoenix release with the following commit in it:
	# https://github.com/phoenixframework/phoenix/commit/2e8c63c01fec4dde5467dbbbf9705ff9e780735e

	plug(RateLimiter, [name: :timeline, bucket_name: :direct_timeline] when action == :direct)
	plug(RateLimiter, [name: :timeline, bucket_name: :public_timeline] when action == :public)
	plug(RateLimiter, [name: :timeline, bucket_name: :home_timeline] when action == :home)
	plug(RateLimiter, [name: :timeline, bucket_name: :hashtag_timeline] when action == :hashtag)
	plug(RateLimiter, [name: :timeline, bucket_name: :list_timeline] when action == :list)

	plug(OAuthScopesPlug, %{scopes: ["read:statuses"]} when action in [:home, :direct])
	plug(OAuthScopesPlug, %{scopes: ["read:lists"]} when action == :list)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:statuses"], fallback: :proceed_unauthenticated}
	when action in [:public, :hashtag]
	)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.TimelineOperation

	# GET /api/v1/timelines/home
	def home(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:announce_filtering_user, user)
	+ \|> Map.put(:phrase_filtering_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:local_only, params[:local])
	\|> Map.delete(:local)

	activities =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(activities)
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	end

	# GET /api/v1/timelines/direct
	def direct(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put(:type, "Create")
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:visibility, "direct")

	activities =
	[user.ap_id]
	\|> ActivityPub.fetch_activities_query(params)
	\|> Pagination.fetch_paginated(params)

	conn
	\|> add_link_headers(activities)
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity
	)
	end

	defp restrict_unauthenticated?(true = _local_only) do
	Config.restrict_unauthenticated_access?(:timelines, :local)
	end

	defp restrict_unauthenticated?(_) do
	Config.restrict_unauthenticated_access?(:timelines, :federated)
	end

	# GET /api/v1/timelines/public
	def public(%{assigns: %{user: user}} = conn, params) do
	local_only = params[:local]

	if is_nil(user) and restrict_unauthenticated?(local_only) do
	fail_on_bad_auth(conn)
	else
	activities =
	params
	\|> Map.put(:type, ["Create"])
	\|> Map.put(:local_only, local_only)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:instance, params[:instance])
	# Restricts unfederated content to authenticated users
	\|> Map.put(:includes_local_public, not is_nil(user))
	\|> ActivityPub.fetch_public_activities()

	conn
	\|> add_link_headers(activities, %{"local" => local_only})
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	end
	end

	defp fail_on_bad_auth(conn) do
	render_error(conn, :unauthorized, "authorization required for timeline view")
	end

	defp hashtag_fetching(params, user, local_only) do
	# Note: not sanitizing tag options at this stage (may be mix-cased, have duplicates etc.)
	tags_any =
	[params[:tag], params[:any]]
	\|> List.flatten()
	\|> Enum.filter(& &1)

	tag_all = Map.get(params, :all, [])
	tag_reject = Map.get(params, :none, [])

	params
	\|> Map.put(:type, "Create")
	\|> Map.put(:local_only, local_only)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:tag, tags_any)
	\|> Map.put(:tag_all, tag_all)
	\|> Map.put(:tag_reject, tag_reject)
	\|> ActivityPub.fetch_public_activities()
	end

	# GET /api/v1/timelines/tag/:tag
	def hashtag(%{assigns: %{user: user}} = conn, params) do
	local_only = params[:local]

	if is_nil(user) and restrict_unauthenticated?(local_only) do
	fail_on_bad_auth(conn)
	else
	activities = hashtag_fetching(params, user, local_only)

	conn
	\|> add_link_headers(activities, %{"local" => local_only})
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	end
	end

	# GET /api/v1/timelines/list/:list_id
	def list(%{assigns: %{user: user}} = conn, %{list_id: id} = params) do
	with %Pleroma.List{title: _title, following: following} <- Pleroma.List.get(id, user) do
	params =
	params
	\|> Map.put(:type, "Create")
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:local_only, params[:local])

	# we must filter the following list for the user to avoid leaking statuses the user
	# does not actually have permission to see (for more info, peruse security issue #270).

	user_following = User.following(user)

	activities =
	following
	\|> Enum.filter(fn x -> x in user_following end)
	\|> ActivityPub.fetch_activities_bounded(following, params)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(activities)
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	else
	_e -> render_error(conn, :forbidden, "Error.")
	end
	end
	end
	diff --git a/test/pleroma/notification_test.exs b/test/pleroma/notification_test.exs
	index e595c5c53..213d234e7 100644
	--- a/test/pleroma/notification_test.exs
	+++ b/test/pleroma/notification_test.exs
	@@ -1,1125 +1,1125 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase, async: false

	import Pleroma.Factory

	alias Pleroma.FollowingRelationship
	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.NotificationView

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	:ok
	end

	describe "create_notifications" do
	test "never returns nil" do
	user = insert(:user)
	other_user = insert(:user, %{invisible: true})

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
	{:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	refute {:ok, [nil]} == Notification.create_notifications(activity)
	end

	test "creates a report notification only for privileged users" do
	reporting_user = insert(:user)
	reported_user = insert(:user)
	moderator_user = insert(:user, is_moderator: true)

	clear_config([:instance, :moderator_privileges], [])
	{:ok, activity1} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, []} = Notification.create_notifications(activity1)

	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])
	{:ok, activity2} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, [notification]} = Notification.create_notifications(activity2)

	assert notification.user_id == moderator_user.id
	assert notification.type == "pleroma:report"
	end

	test "suppresses notifications for own reports" do
	clear_config([:instance, :admin_privileges], [:reports_manage_reports])

	reporting_admin = insert(:user, is_admin: true)
	reported_user = insert(:user)
	other_admin = insert(:user, is_admin: true)

	{:ok, activity} = CommonAPI.report(reporting_admin, %{account_id: reported_user.id})

	{:ok, [notification]} = Notification.create_notifications(activity)

	refute notification.user_id == reporting_admin.id
	assert notification.user_id == other_admin.id
	assert notification.type == "pleroma:report"
	end

	test "creates a notification for an emoji reaction" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
	{:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	{:ok, [notification]} = Notification.create_notifications(activity)

	assert notification.user_id == user.id
	assert notification.type == "pleroma:emoji_reaction"
	end

	test "notifies someone when they are directly addressed" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname} and @#{third_user.nickname}"
	})

	{:ok, [notification, other_notification]} = Notification.create_notifications(activity)

	notified_ids = Enum.sort([notification.user_id, other_notification.user_id])
	assert notified_ids == [other_user.id, third_user.id]
	assert notification.activity_id == activity.id
	assert notification.type == "mention"
	assert other_notification.activity_id == activity.id

	assert [%Pleroma.Marker{unread_count: 2}] =
	Pleroma.Marker.get_markers(other_user, ["notifications"])
	end

	test "it creates a notification for subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
	{:ok, [notification]} = Notification.create_notifications(status)

	assert notification.user_id == subscriber.id
	assert notification.type == "status"
	end

	test "does not create a notification for subscribed users if status is a reply" do
	user = insert(:user)
	other_user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, other_user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})

	{:ok, _reply_activity} =
	CommonAPI.post(other_user, %{
	status: "test reply",
	in_reply_to_status_id: activity.id
	})

	user_notifications = Notification.for_user(user)
	assert length(user_notifications) == 1

	subscriber_notifications = Notification.for_user(subscriber)
	assert Enum.empty?(subscriber_notifications)
	end

	test "does not create subscriber notification if mentioned" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "mentioning @#{subscriber.nickname}"})
	{:ok, [notification] = notifications} = Notification.create_notifications(status)

	assert length(notifications) == 1

	assert notification.user_id == subscriber.id
	assert notification.type == "mention"
	end

	test "it sends edited notifications to those who repeated a status" do
	user = insert(:user)
	repeated_user = insert(:user)
	other_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, _activity_two} = CommonAPI.repeat(activity_one.id, repeated_user)

	{:ok, _edit_activity} =
	CommonAPI.update(activity_one, user, %{
	status: "hey @#{other_user.nickname}! mew mew"
	})

	assert [%{type: "reblog"}] = Notification.for_user(user)
	assert [%{type: "update"}] = Notification.for_user(repeated_user)
	assert [%{type: "mention"}] = Notification.for_user(other_user)
	end
	end

	test "create_poll_notifications/1" do
	[user1, user2, user3, _, _] = insert_list(5, :user)
	question = insert(:question, user: user1)
	activity = insert(:question_activity, question: question)

	{:ok, _, _} = CommonAPI.vote(question, user2, [0])
	{:ok, _, _} = CommonAPI.vote(question, user3, [1])

	{:ok, notifications} = Notification.create_poll_notifications(activity)

	assert [user2.id, user3.id, user1.id] == Enum.map(notifications, & &1.user_id)
	end

	describe "create_notification" do
	test "it disables notifications from strangers" do
	follower = insert(:user)

	followed =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	{:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it disables notifications from non-followees" do
	follower = insert(:user)

	followed =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	CommonAPI.follow(followed, follower)
	{:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it allows notifications from followees" do
	poster = insert(:user)

	receiver =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	CommonAPI.follow(poster, receiver)
	{:ok, activity} = CommonAPI.post(poster, %{status: "hey @#{receiver.nickname}"})
	assert Notification.create_notification(activity, receiver)
	end

	test "it doesn't create a notification for user if he is the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])

	refute Notification.create_notification(activity, author)
	end

	test "it doesn't create duplicate notifications for follow+subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, subscriber)
	User.subscribe(subscriber, user)
	{:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
	{:ok, [_notif]} = Notification.create_notifications(status)
	end

	test "it doesn't create subscription notifications if the recipient cannot see the status" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "inwisible", visibility: "direct"})

	assert {:ok, []} == Notification.create_notifications(status)
	end

	test "it disables notifications from people who are invisible" do
	author = insert(:user, invisible: true)
	user = insert(:user)

	{:ok, status} = CommonAPI.post(author, %{status: "hey @#{user.nickname}"})
	refute Notification.create_notification(status, user)
	end

	test "it doesn't create notifications if content matches with an irreversible filter" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)
	- insert(:filter, user: subscriber, phrase: "cofe", hide: true)
	+ insert(:filter, user: subscriber, phrase: "cofe", context: ["notifications"], hide: true)

	{:ok, status} = CommonAPI.post(user, %{status: "got cofe?"})

	assert {:ok, []} == Notification.create_notifications(status)
	end

	test "it creates notifications if content matches with a not irreversible filter" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)
	insert(:filter, user: subscriber, phrase: "cofe", hide: false)

	{:ok, status} = CommonAPI.post(user, %{status: "got cofe?"})
	{:ok, [notification]} = Notification.create_notifications(status)

	assert notification
	refute notification.seen
	end

	test "it creates notifications when someone likes user's status with a filtered word" do
	user = insert(:user)
	other_user = insert(:user)
	insert(:filter, user: user, phrase: "tesla", hide: true)

	{:ok, activity_one} = CommonAPI.post(user, %{status: "wow tesla"})
	{:ok, activity_two} = CommonAPI.favorite(activity_one.id, other_user)

	{:ok, [notification]} = Notification.create_notifications(activity_two)

	assert notification
	refute notification.seen
	end
	end

	describe "follow / follow_request notifications" do
	test "it creates `follow` notification for approved Follow activity" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: false)

	{:ok, _, _, _activity} = CommonAPI.follow(followed_user, user)
	assert FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})
	end

	test "it creates `follow_request` notification for pending Follow activity" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: true)

	{:ok, _, _, _activity} = CommonAPI.follow(followed_user, user)
	refute FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	render_opts = %{notification: notification, for: followed_user}
	assert %{type: "follow_request"} = NotificationView.render("show.json", render_opts)

	# After request is accepted, the same notification is rendered with type "follow":
	assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)

	notification =
	Repo.get(Notification, notification.id)
	\|> Repo.preload(:activity)

	assert %{type: "follow"} =
	NotificationView.render("show.json",
	notification: notification,
	for: followed_user
	)
	end

	test "it doesn't create a notification for follow-unfollow-follow chains" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: false)

	{:ok, _, _, _activity} = CommonAPI.follow(followed_user, user)
	assert FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	CommonAPI.unfollow(followed_user, user)
	{:ok, _, _, _activity_dupe} = CommonAPI.follow(followed_user, user)

	notification_id = notification.id
	assert [%{id: ^notification_id}] = Notification.for_user(followed_user)
	end

	test "dismisses the notification on follow request rejection" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	{:ok, _, _, _follow_activity} = CommonAPI.follow(user, follower)
	assert [_notification] = Notification.for_user(user)
	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)
	assert [] = Notification.for_user(user)
	end
	end

	describe "get notification" do
	test "it gets a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.get(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.get(user, notification.id)
	end
	end

	describe "dismiss notification" do
	test "it dismisses a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.dismiss(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.dismiss(user, notification.id)
	end
	end

	describe "clear notification" do
	test "it clears all notifications belonging to the user" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)
	Notification.clear(other_user)

	assert Notification.for_user(other_user) == []
	assert Notification.for_user(third_user) != []
	end
	end

	describe "set_read_up_to()" do
	test "it sets all notifications as read up to a specified notification ID" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "hey again @#{other_user.nickname}!"
	})

	[n2, n1] = Notification.for_user(other_user)

	assert n2.id > n1.id

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "hey yet again @#{other_user.nickname}!"
	})

	Notification.set_read_up_to(other_user, n2.id)

	[n3, n2, n1] = Notification.for_user(other_user)

	assert n1.seen == true
	assert n2.seen == true
	assert n3.seen == false

	assert %Pleroma.Marker{} =
	m =
	Pleroma.Repo.get_by(
	Pleroma.Marker,
	user_id: other_user.id,
	timeline: "notifications"
	)

	assert m.last_read_id == to_string(n2.id)
	end
	end

	describe "for_user_since/2" do
	defp days_ago(days) do
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-days * 60 * 60 * 24,
	:second
	)
	end

	test "Returns recent notifications" do
	user1 = insert(:user)
	user2 = insert(:user)

	Enum.each(0..10, fn i ->
	{:ok, _activity} =
	CommonAPI.post(user1, %{
	status: "hey ##{i} @#{user2.nickname}!"
	})
	end)

	{old, new} = Enum.split(Notification.for_user(user2), 5)

	Enum.each(old, fn notification ->
	notification
	\|> cast(%{updated_at: days_ago(10)}, [:updated_at])
	\|> Pleroma.Repo.update!()
	end)

	recent_notifications_ids =
	user2
	\|> Notification.for_user_since(
	NaiveDateTime.add(NaiveDateTime.utc_now(), -5 * 86_400, :second)
	)
	\|> Enum.map(& &1.id)

	Enum.each(old, fn %{id: id} ->
	refute id in recent_notifications_ids
	end)

	Enum.each(new, fn %{id: id} ->
	assert id in recent_notifications_ids
	end)
	end
	end

	describe "notification target determination / get_notified_from_activity/2" do
	test "it sends notifications to addressed users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

	test "it sends notifications to mentioned users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"content" => "message with a Mention tag, but no explicit tagging",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => other_user.ap_id,
	"name" => other_user.nickname
	}
	],
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

	test "it does not send notifications to users who are only cc in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [other_user.ap_id],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [other_user.ap_id],
	"content" => "hi everyone",
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user not in enabled_receivers
	end

	test "it does not send notification to mentioned users in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two} = CommonAPI.favorite(activity_one.id, third_user)

	enabled_receivers = Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it only notifies the post's author in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, like_data, _} = Builder.like(third_user, activity_one.object)

	{:ok, like, _} =
	like_data
	\|> Map.put("to", [other_user.ap_id \| like_data["to"]])
	\|> ActivityPub.persist(local: true)

	enabled_receivers = Notification.get_notified_from_activity(like)

	assert other_user not in enabled_receivers
	end

	test "it does not send notification to mentioned users in announces" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two} = CommonAPI.repeat(activity_one.id, third_user)

	enabled_receivers = Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it does not return blocking recipient in recipients list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(other_user, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

	test "it does not return notification-muting recipient in recipients list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationships} = User.mute(other_user, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

	test "it does not return thread-muting recipient in recipients list" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})

	{:ok, _} = CommonAPI.add_mute(activity, other_user)

	{:ok, same_context_activity} =
	CommonAPI.post(user, %{
	status: "hey-hey-hey @#{other_user.nickname}!",
	in_reply_to_status_id: activity.id
	})

	enabled_receivers = Notification.get_notified_from_activity(same_context_activity)

	refute other_user in enabled_receivers
	end

	test "it does not return non-following domain-blocking recipient in recipients list" do
	blocked_domain = "blocked.domain"
	user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
	other_user = insert(:user)

	{:ok, other_user} = User.block_domain(other_user, blocked_domain)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

	test "it returns following domain-blocking recipient in enabled recipients list" do
	blocked_domain = "blocked.domain"
	user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
	other_user = insert(:user)

	{:ok, other_user} = User.block_domain(other_user, blocked_domain)
	{:ok, other_user, user} = User.follow(other_user, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [other_user] == enabled_receivers
	end

	test "it sends edited notifications to those who repeated a status" do
	user = insert(:user)
	repeated_user = insert(:user)
	other_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}!"
	})

	{:ok, _activity_two} = CommonAPI.repeat(activity_one.id, repeated_user)

	{:ok, edit_activity} =
	CommonAPI.update(activity_one, user, %{
	status: "hey @#{other_user.nickname}! mew mew"
	})

	enabled_receivers = Notification.get_notified_from_activity(edit_activity)

	assert repeated_user in enabled_receivers
	refute other_user in enabled_receivers
	end
	end

	describe "notification lifecycle" do
	test "liking an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity results in 1 notification, then 0 if the activity is unliked" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.unfavorite(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is unrepeated" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.unrepeat(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))

	{:error, :not_found} = CommonAPI.favorite(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))

	{:error, _} = CommonAPI.repeat(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "notifications are deleted if a local user is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "hi @#{other_user.nickname}", visibility: "direct"})

	refute Enum.empty?(Notification.for_user(other_user))

	{:ok, job} = User.delete(user)
	ObanHelpers.perform(job)

	assert Enum.empty?(Notification.for_user(other_user))
	end

	test "notifications are deleted if a remote user is deleted" do
	remote_user = insert(:user)
	local_user = insert(:user)

	dm_message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => remote_user.ap_id,
	"id" => remote_user.ap_id <> "/activities/test",
	"to" => [local_user.ap_id],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => remote_user.ap_id <> "/objects/test",
	"content" => "Hello!",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => local_user.ap_id,
	"name" => "@#{local_user.nickname}"
	}
	],
	"to" => [local_user.ap_id],
	"cc" => [],
	"attributedTo" => remote_user.ap_id
	}
	}

	{:ok, _dm_activity} = Transmogrifier.handle_incoming(dm_message)

	refute Enum.empty?(Notification.for_user(local_user))

	delete_user_message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => remote_user.ap_id <> "/activities/delete",
	"actor" => remote_user.ap_id,
	"type" => "Delete",
	"object" => remote_user.ap_id
	}

	remote_user_url = remote_user.ap_id

	Tesla.Mock.mock(fn
	%{method: :get, url: ^remote_user_url} ->
	%Tesla.Env{status: 404, body: ""}
	end)

	{:ok, _delete_activity} = Transmogrifier.handle_incoming(delete_user_message)
	ObanHelpers.perform_all()

	assert Enum.empty?(Notification.for_user(local_user))
	end

	test "move activity generates a notification" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	other_follower = insert(:user, %{allow_following_move: false})

	User.follow(follower, old_user)
	User.follow(other_follower, old_user)

	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	ObanHelpers.perform_all()

	assert [
	%{
	activity: %{
	data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
	}
	}
	] = Notification.for_user(follower)

	assert [
	%{
	activity: %{
	data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
	}
	}
	] = Notification.for_user(other_follower)
	end
	end

	describe "for_user" do
	setup do
	user = insert(:user)

	{:ok, %{user: user}}
	end

	test "it returns notifications for muted user without notifications", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted, %{notifications: false})

	{:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

	[notification] = Notification.for_user(user)

	assert notification.activity.object
	assert notification.seen
	end

	test "it doesn't return notifications for muted user with notifications", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

	{:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for blocked user", %{user: user} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for domain-blocked non-followed user", %{user: user} do
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it returns notifications for domain-blocked but followed user" do
	user = insert(:user)
	blocked = insert(:user, ap_id: "http://some-domain.com")

	{:ok, user} = User.block_domain(user, "some-domain.com")
	{:ok, _, _} = User.follow(user, blocked)

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert length(Notification.for_user(user)) == 1
	end

	test "it doesn't return notifications for muted thread", %{user: user} do
	another_user = insert(:user)

	{:ok, activity} = CommonAPI.post(another_user, %{status: "hey @#{user.nickname}"})

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications from a muted user when with_muted is set", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

	{:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "it doesn't return notifications from a blocked user when with_muted is set", %{
	user: user
	} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "when with_muted is set, " <>
	"it doesn't return notifications from a domain-blocked non-followed user",
	%{user: user} do
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "it returns notifications from muted threads when with_muted is set", %{user: user} do
	another_user = insert(:user)

	{:ok, activity} = CommonAPI.post(another_user, %{status: "hey @#{user.nickname}"})

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end

	test "it doesn't return notifications about mentions with filtered word", %{user: user} do
	- insert(:filter, user: user, phrase: "cofe", hide: true)
	+ insert(:filter, user: user, phrase: "cofe", context: ["notifications"], hide: true)
	another_user = insert(:user)

	{:ok, _activity} = CommonAPI.post(another_user, %{status: "@#{user.nickname} got cofe?"})

	assert Enum.empty?(Notification.for_user(user))
	end

	test "it returns notifications about mentions with not hidden filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "test", hide: false)
	another_user = insert(:user)

	{:ok, _} = CommonAPI.post(another_user, %{status: "@#{user.nickname} test"})

	assert length(Notification.for_user(user)) == 1
	end

	test "it returns notifications about favorites with filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "cofe", hide: true)
	another_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Give me my cofe!"})
	{:ok, _} = CommonAPI.favorite(activity.id, another_user)

	assert length(Notification.for_user(user)) == 1
	end

	test "it returns notifications when related object is without content and filters are defined",
	%{user: user} do
	followed_user = insert(:user, is_locked: true)

	insert(:filter, user: followed_user, phrase: "test", hide: true)

	{:ok, _, _, _activity} = CommonAPI.follow(followed_user, user)
	refute FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow_request"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})

	assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)

	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/activity_pub_test.exs b/test/pleroma/web/activity_pub/activity_pub_test.exs
	index b4f6fb68a..51303e9fd 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_test.exs
	@@ -1,2715 +1,2717 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Config
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Mock
	import Mox
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)

	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	:ok
	end

	setup do: clear_config([:instance, :federating])

	describe "streaming out participations" do
	test "it streams them out" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)

	participations =
	conversation.participations
	\|> Repo.preload(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	ActivityPub.stream_out_participations(conversation.participations)

	assert called(Pleroma.Web.Streamer.stream("participation", participations))
	end
	end

	test "streams them out on activity creation" do
	user_one = insert(:user)
	user_two = insert(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	{:ok, activity} =
	CommonAPI.post(user_one, %{
	status: "@#{user_two.nickname}",
	visibility: "direct"
	})

	conversation =
	activity.data["context"]
	\|> Pleroma.Conversation.get_for_ap_id()
	\|> Repo.preload(participations: :user)

	assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
	end
	end
	end

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	activities = ActivityPub.fetch_activities([], %{visibility: "direct", actor_id: user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "unlisted", actor_id: user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "private", actor_id: user.ap_id})

	assert activities == [private_activity]

	activities = ActivityPub.fetch_activities([], %{visibility: "public", actor_id: user.ap_id})

	assert activities == [public_activity]

	activities =
	ActivityPub.fetch_activities([], %{
	visibility: ~w[private public],
	actor_id: user.ap_id
	})

	assert activities == [public_activity, private_activity]
	end
	end

	describe "fetching excluded by visibility" do
	test "it excludes by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "direct",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	refute direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "unlisted",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	refute unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "private",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	refute private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "public",
	actor_id: user.ap_id
	})

	refute public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it returns a user that is invisible" do
	user_id = "http://mastodon.example.org/users/relay"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert User.invisible?(user)
	end

	test "it returns a user that accepts chat messages" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.accepts_chat_messages
	end

	test "works for guppe actors" do
	user_id = "https://gup.pe/u/bernie2020"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/guppe-actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.name == "Bernie2020 group"
	assert user.actor_type == "Group"
	end

	test "works for bridgy actors" do
	user_id = "https://fed.brid.gy/jk.nipponalba.scot"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/bridgy/actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.actor_type == "Person"

	assert user.avatar == %{
	"type" => "Image",
	"url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}]
	}

	assert user.banner == %{
	"type" => "Image",
	"url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}]
	}
	end

	test "fetches user featured collection" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	object_data =
	"test/fixtures/statuses/note.json"
	\|> File.read!()
	\|> String.replace("{{object_id}}", object_id)
	\|> String.replace("{{nickname}}", "lain")

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^ap_id
	} ->
	%Tesla.Env{
	status: 200,
	body: user_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^featured_url
	} ->
	%Tesla.Env{
	status: 200,
	body: featured_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: object_data,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)

	assert_enqueued(
	worker: Pleroma.Workers.RemoteFetcherWorker,
	args: %{
	"op" => "fetch_remote",
	"id" => object_url,
	"depth" => 1
	}
	)

	# wait for oban
	Pleroma.Tests.ObanHelpers.perform_all()

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end

	test "fetches user featured collection without embedded object" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/external_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	object_data =
	"test/fixtures/statuses/note.json"
	\|> File.read!()
	\|> String.replace("{{object_id}}", object_id)
	\|> String.replace("{{nickname}}", "lain")

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^ap_id
	} ->
	%Tesla.Env{
	status: 200,
	body: user_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^featured_url
	} ->
	%Tesla.Env{
	status: 200,
	body: featured_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: object_data,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)

	assert_enqueued(
	worker: Pleroma.Workers.RemoteFetcherWorker,
	args: %{
	"op" => "fetch_remote",
	"id" => object_url,
	"depth" => 1
	}
	)

	# wait for oban
	Pleroma.Tests.ObanHelpers.perform_all()

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end

	test "fetches user birthday information from misskey" do
	user_id = "https://misskey.io/@mkljczk"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^user_id
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/birthdays/misskey-user.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.birthday == ~D[2001-02-12]
	end
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{status: ". #TEST"})
	{:ok, status_two} = CommonAPI.post(user, %{status: ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{status: ". #test #Reject"})

	{:ok, status_four} = CommonAPI.post(user, %{status: ". #Any1 #any2"})
	{:ok, status_five} = CommonAPI.post(user, %{status: ". #Any2 #any1"})

	for hashtag_timeline_strategy <- [:enabled, :disabled] do
	clear_config([:features, :improved_hashtag_timeline], hashtag_timeline_strategy)

	fetch_one = ActivityPub.fetch_activities([], %{type: "Create", tag: "test"})

	fetch_two = ActivityPub.fetch_activities([], %{type: "Create", tag: ["TEST", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test", "Essais"],
	tag_reject: ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test"],
	tag_all: ["test", "REJECT"]
	})

	# Testing that deduplication (if needed) is done on DB (not Ecto) level; :limit is important
	fetch_five =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["ANY1", "any2"],
	limit: 2
	})

	fetch_six =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["any1", "Any2"],
	tag_all: [],
	tag_reject: []
	})

	# Regression test: passing empty lists as filter options shouldn't affect the results
	assert fetch_five == fetch_six

	[fetch_one, fetch_two, fetch_three, fetch_four, fetch_five] =
	Enum.map([fetch_one, fetch_two, fetch_three, fetch_four, fetch_five], fn statuses ->
	Enum.map(statuses, fn s -> Repo.preload(s, object: :hashtags) end)
	end)

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	assert fetch_five == [status_four, status_five]
	end
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, :remote_limit} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity.id == new_activity.id
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"id" => given_id,
	"actor" => user.ap_id,
	"to" => [],
	"context" => "blabla",
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	end

	test "adds a context when none is there" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	object = Pleroma.Object.normalize(activity, fetch: false)

	assert is_binary(activity.data["context"])
	assert is_binary(object.data["context"])
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert object = Object.normalize(activity, fetch: false)
	assert is_binary(object.data["id"])
	end
	end

	describe "listen activities" do
	test "does not increase user note count" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.listen(%{
	to: ["https://www.w3.org/ns/activitystreams#Public"],
	actor: user,
	context: "",
	object: %{
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"artist" => "lain",
	"title" => "lain radio episode 1",
	"length" => 180_000,
	"type" => "Audio"
	}
	})

	assert activity.actor == user.ap_id

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 0
	end

	test "can be fetched into a timeline" do
	_listen_activity_1 = insert(:listen)
	_listen_activity_2 = insert(:listen)
	_listen_activity_3 = insert(:listen)

	timeline = ActivityPub.fetch_activities([], %{type: ["Listen"]})

	assert length(timeline) == 3
	end
	end

	describe "create activities" do
	setup do
	[user: insert(:user)]
	end

	test "it reverts create", %{user: user} do
	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "creates activity if expiration is not configured and expires_at is not passed", %{
	user: user
	} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:ok, _} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	test "rejects activity if expires_at present but expiration is not configured", %{user: user} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:error, :expired_activities_disabled} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	},
	additional: %{
	"expires_at" => DateTime.utc_now()
	}
	})

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "removes doubled 'to' recipients", %{user: user} do
	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2", user.ap_id]
	end

	test "increases user note count only for public activities", %{user: user} do
	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "1",
	visibility: "public"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "unlisted"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "private"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "3",
	visibility: "direct"
	})

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 2
	end

	test "increases replies count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	reply_data = %{status: "1", in_reply_to_status_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "public"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "unlisted"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "private"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "direct"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2
	end

	test "increates quotes count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	quote_data = %{status: "1", quote_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "public"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "unlisted"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "private"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "direct"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{blocking_user: user})
	assert activities == [activity_two, activity]
	end

	test "doesn't return activities with filtered words" do
	user = insert(:user)
	user_two = insert(:user)
	- insert(:filter, user: user, phrase: "test", hide: true)
	+ insert(:filter, user: user, phrase: "test", context: ["home"], hide: true)

	{:ok, %{id: id1, data: %{"context" => context}}} = CommonAPI.post(user, %{status: "1"})

	{:ok, %{id: id2}} = CommonAPI.post(user_two, %{status: "2", in_reply_to_status_id: id1})

	{:ok, %{id: id3} = user_activity} =
	CommonAPI.post(user, %{status: "3 test?", in_reply_to_status_id: id2})

	{:ok, %{id: id4} = filtered_activity} =
	CommonAPI.post(user_two, %{status: "4 test!", in_reply_to_status_id: id3})

	{:ok, _} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})

	activities =
	context
	- \|> ActivityPub.fetch_activities_for_context(%{user: user})
	+ \|> ActivityPub.fetch_activities_for_context(%{user: user, phrase_filtering_user: user})
	\|> Enum.map(& &1.id)

	assert length(activities) == 4
	assert user_activity.id in activities
	refute filtered_activity.id in activities
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{blocking_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return activities from deactivated users" do
	_user = insert(:user)
	deactivated = insert(:user)
	active = insert(:user)
	{:ok, activity_one} = CommonAPI.post(deactivated, %{status: "hey!"})
	{:ok, activity_two} = CommonAPI.post(active, %{status: "yay!"})
	{:ok, _updated_user} = User.set_activation(deactivated, false)

	activities = ActivityPub.fetch_activities([], %{})

	refute Enum.member?(activities, activity_one)
	assert Enum.member?(activities, activity_two)
	end

	test "always see your own posts even when they address people you block" do
	user = insert(:user)
	blockee = insert(:user)

	{:ok, _} = User.block(user, blockee)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey! @#{blockee.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "doesn't return transitive interactions concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})

	{:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_four} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker})

	assert Enum.member?(activities, activity_one)
	refute Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_four)
	end

	test "doesn't return announce activities with blocked users in 'to'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_three} = CommonAPI.repeat(activity_two.id, friend)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return announce activities with blocked users in 'cc'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	assert object = Pleroma.Object.normalize(activity_two, fetch: false)

	data = %{
	"actor" => friend.ap_id,
	"object" => object.data["id"],
	"context" => object.data["context"],
	"type" => "Announce",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [blockee.ap_id]
	}

	assert {:ok, activity_three} = ActivityPub.insert(data)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return activities from blocked domains" do
	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})
	user = insert(:user)
	{:ok, user} = User.block_domain(user, domain)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute activity in activities

	followed_user = insert(:user)
	CommonAPI.follow(followed_user, user)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, followed_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute repeat_activity in activities
	end

	test "see your own posts even when they address actors from blocked domains" do
	user = insert(:user)

	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})

	{:ok, user} = User.block_domain(user, domain)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey! @#{domain_user.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "does return activities from followed users on blocked domains" do
	domain = "meanies.social"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	blocker = insert(:user)

	{:ok, blocker, domain_user} = User.follow(blocker, domain_user)
	{:ok, blocker} = User.block_domain(blocker, domain)

	assert User.following?(blocker, domain_user)
	assert User.blocks_domain?(blocker, domain_user)
	refute User.blocks?(blocker, domain_user)

	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	assert activity in activities

	# And check that if the guy we DO follow boosts someone else from their domain,
	# that should be hidden
	another_user = insert(:user, %{ap_id: "https://#{domain}/@meanie2"})
	bad_note = insert(:note, %{data: %{"actor" => another_user.ap_id}})
	bad_activity = insert(:note_activity, %{note: bad_note})
	{:ok, repeat_activity} = CommonAPI.repeat(bad_activity.id, domain_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	refute repeat_activity in activities
	end

	test "returns your own posts regardless of mute" do
	user = insert(:user)
	muted = insert(:user)

	{:ok, muted_post} = CommonAPI.post(muted, %{status: "Im stupid"})

	{:ok, reply} =
	CommonAPI.post(user, %{status: "I'm muting you", in_reply_to_status_id: muted_post.id})

	{:ok, _} = User.mute(user, muted)

	[activity] = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert activity.id == reply.id
	end

	test "doesn't return muted activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	activity_one_actor = User.get_by_ap_id(activity_one.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	# Calling with 'with_muted' will deliver muted activities, too.
	activities =
	ActivityPub.fetch_activities([], %{
	muting_user: user,
	with_muted: true,
	skip_preload: true
	})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_mute} = User.unmute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	activity_three_actor = User.get_by_ap_id(activity_three.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_three_actor)
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{muting_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return thread muted activities" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(activity_two, user)

	assert [_activity_one] = ActivityPub.fetch_activities([], %{muting_user: user})
	end

	test "returns thread muted activities when with_muted is set" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(activity_two, user)

	assert [_activity_two, _activity_one] =
	ActivityPub.fetch_activities([], %{muting_user: user, with_muted: true})
	end

	test "does include announces on request" do
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	{:ok, user, booster} = User.follow(user, booster)

	{:ok, announce} = CommonAPI.repeat(activity_three.id, booster)

	[announce_activity] = ActivityPub.fetch_activities([user.ap_id \| User.following(user)])

	assert announce_activity.id == announce.id
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{exclude_reblogs: true})

	assert activity == expected_activity
	end

	describe "irreversible filters" do
	setup do
	user = insert(:user)
	user_two = insert(:user)

	- insert(:filter, user: user_two, phrase: "cofe", hide: true)
	- insert(:filter, user: user_two, phrase: "ok boomer", hide: true)
	- insert(:filter, user: user_two, phrase: "test", hide: false)
	+ insert(:filter, user: user_two, phrase: "cofe", context: ["home"], hide: true)
	+ insert(:filter, user: user_two, phrase: "ok boomer", context: ["home"], hide: true)
	+ insert(:filter, user: user_two, phrase: "test", context: ["home"], hide: false)

	params = %{
	type: ["Create", "Announce"],
	- user: user_two
	+ user: user_two,
	+ phrase_filtering_user: user_two
	}

	{:ok, %{user: user, user_two: user_two, params: params}}
	end

	test "it returns statuses if they don't contain exact filter words", %{
	user: user,
	params: params
	} do
	{:ok, _} = CommonAPI.post(user, %{status: "hey"})
	{:ok, _} = CommonAPI.post(user, %{status: "got cofefe?"})
	{:ok, _} = CommonAPI.post(user, %{status: "I am not a boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomers"})
	{:ok, _} = CommonAPI.post(user, %{status: "ccofee is not a word"})
	{:ok, _} = CommonAPI.post(user, %{status: "this is a test"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 6
	end

	test "it does not filter user's own statuses", %{user_two: user_two, params: params} do
	{:ok, _} = CommonAPI.post(user_two, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user_two, %{status: "ok boomer"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 2
	end

	test "it excludes statuses with filter words", %{user: user, params: params} do
	{:ok, _} = CommonAPI.post(user, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "is it a cOfE?"})
	{:ok, _} = CommonAPI.post(user, %{status: "cofe is all I need"})
	{:ok, _} = CommonAPI.post(user, %{status: "— ok BOOMER\n"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.empty?(activities)
	end

	test "it returns all statuses if user does not have any filters" do
	another_user = insert(:user)
	{:ok, _} = CommonAPI.post(another_user, %{status: "got cofe?"})
	{:ok, _} = CommonAPI.post(another_user, %{status: "test!"})

	activities =
	ActivityPub.fetch_activities([], %{
	type: ["Create", "Announce"],
	- user: another_user
	+ user: another_user,
	+ phrase_filtering_user: another_user
	})

	assert Enum.count(activities) == 2
	end
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} = CommonAPI.post(user, %{status: "yeah", visibility: "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{status: "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	activities = ActivityPub.fetch_public_activities()

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 20
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	expected_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id

	activities = ActivityPub.fetch_public_activities(%{since_id: since_id})

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 10
	end

	test "retrieves ids up to max_id" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	%{id: max_id} =
	10
	\|> ActivityBuilder.insert_list()
	\|> List.first()

	activities = ActivityPub.fetch_public_activities(%{max_id: max_id})

	assert length(activities) == 20
	assert collect_ids(activities) == collect_ids(expected_activities)
	end

	test "paginates via offset/limit" do
	_first_part_activities = ActivityBuilder.insert_list(10)
	second_part_activities = ActivityBuilder.insert_list(10)

	later_activities = ActivityBuilder.insert_list(10)

	activities = ActivityPub.fetch_public_activities(%{page: "2", page_size: "20"}, :offset)

	assert length(activities) == 20

	assert collect_ids(activities) ==
	collect_ids(second_part_activities) ++ collect_ids(later_activities)
	end

	test "doesn't return reblogs for users for whom reblogs have been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(booster, user)

	{:ok, activity} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end

	test "returns reblogs for users for whom reblogs have not been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(booster, user)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(booster, user)

	{:ok, activity} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end
	end

	describe "uploading files" do
	setup do
	test_file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	%{test_file: test_file}
	end

	test "strips / from filename", %{test_file: file} do
	file = %Plug.Upload{file \| filename: "../../../../../nested/bad.jpg"}
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	[%{"href" => href}] = object.data["url"]
	assert Regex.match?(~r"/bad.jpg$", href)
	refute Regex.match?(~r"/nested/", href)
	end

	test "sets a description if given", %{test_file: file} do
	{:ok, %Object{} = object} = ActivityPub.upload(file, description: "a cool file")
	assert object.data["name"] == "a cool file"
	end

	test "it sets the default description depending on the configuration", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description])

	clear_config([Pleroma.Upload, :default_description], nil)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == ""

	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"

	clear_config([Pleroma.Upload, :default_description], "unnamed attachment")
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "unnamed attachment"
	end

	test "copies the file to the configured folder", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	img: data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = Repo.get_by(User, ap_id: activity.data["actor"])
	followed = Repo.get_by(User, ap_id: activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "unfollowing" do
	test "it reverts unfollow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(followed, follower)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
	end

	activity = Activity.get_by_id(follow_activity.id)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id

	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(followed, follower)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end

	test "creates an undo activity for a pending follow request" do
	follower = insert(:user)
	followed = insert(:user, %{is_locked: true})

	{:ok, _, _, follow_activity} = CommonAPI.follow(followed, follower)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1, user3} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2, user3} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3, user2} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{status: "hi 1"})

	{:ok, private_activity_1} = CommonAPI.post(user3, %{status: "hi 2", visibility: "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	status: "hi 3",
	visibility: "private",
	in_reply_to_status_id: private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	status: "hi 4",
	visibility: "private",
	in_reply_to_status_id: private_activity_2.id
	})

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)])
	\|> Enum.map(fn a -> a.id end)

	private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])

	assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities

	assert length(activities) == 3

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)], %{user: user1})
	\|> Enum.map(fn a -> a.id end)

	assert [public_activity.id, private_activity_1.id] == activities
	assert length(activities) == 2
	end
	end

	describe "flag/1" do
	setup do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_account.ap_id
	activity_ap_id = activity.data["id"]
	object_ap_id = activity.object.data["id"]

	activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)

	{:ok,
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: activity,
	content: content,
	activity_ap_id: activity_ap_id,
	object_ap_id: object_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	}}
	end

	test "it can create a Flag activity",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content,
	object_ap_id: object_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	} do
	assert {:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	note_obj = %{
	"type" => "Note",
	"id" => object_ap_id,
	"content" => content,
	"published" => activity_with_object.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: target_account, skip_visibility_check: true})
	}

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj]
	}
	} = activity
	end

	test_with_mock "strips status data from Flag, before federating it",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	object_ap_id: object_ap_id,
	content: content
	},
	Utils,
	[:passthrough],
	[] do
	{:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	new_data = put_in(activity.data, ["object"], [target_account.ap_id, object_ap_id])

	assert_called(Utils.maybe_federate(%{activity \| data: new_data}))
	end

	test_with_mock "reverts on error",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content
	},
	Utils,
	[:passthrough],
	maybe_federate: fn _ -> {:error, :reverted} end do
	assert {:error, :reverted} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	assert Repo.aggregate(Activity, :count, :id) == 1
	assert Repo.aggregate(Object, :count, :id) == 1
	assert Repo.aggregate(Notification, :count, :id) == 0
	end
	end

	test "fetch_activities/2 returns activities addressed to a list " do
	user = insert(:user)
	member = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	{:ok, list} = Pleroma.List.follow(list, member)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	activity = Repo.preload(activity, :bookmark)
	activity = %Activity{activity \| thread_muted?: !!activity.thread_muted?}

	assert ActivityPub.fetch_activities([], %{user: user}) == [activity]
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end

	describe "fetch_activities_bounded" do
	test "fetches private posts for followed users" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "thought I looked cute might delete later :3",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
	assert result.id == activity.id
	end

	test "fetches only public posts for other users" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe", visibility: "public"})

	{:ok, _private_activity} =
	CommonAPI.post(user, %{
	status: "why is tenshi eating a corndog so cute?",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
	assert result.id == activity.id
	end
	end

	describe "fetch_follow_information_for_user" do
	test "synchronizes following/followers counters" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/fuser2/followers",
	following_address: "http://localhost:4001/users/fuser2/following"
	)

	{:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
	assert info.follower_count == 527
	assert info.following_count == 267
	end

	test "detects hidden followers" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	_ ->
	apply(HttpRequestMock, :request, [env])
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.hide_follows == false
	end

	test "detects hidden follows" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	_ ->
	apply(HttpRequestMock, :request, [env])
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == false
	assert follow_info.hide_follows == true
	end

	test "detects hidden follows/followers for friendica" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:8080/followers/fuser3",
	following_address: "http://localhost:8080/following/fuser3"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 296
	assert follow_info.following_count == 32
	assert follow_info.hide_follows == true
	end

	test "doesn't crash when follower and following counters are hidden" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_hidden_counters/following" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/followers"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"http://localhost:4001/users/masto_hidden_counters/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	"http://localhost:4001/users/masto_hidden_counters/followers" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/following"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"http://localhost:4001/users/masto_hidden_counters/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_hidden_counters/followers",
	following_address: "http://localhost:4001/users/masto_hidden_counters/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)

	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 0
	assert follow_info.hide_follows == true
	assert follow_info.following_count == 0
	end
	end

	describe "fetch_favourites/3" do
	test "returns a favourite activities sorted by adds to favorite" do
	user = insert(:user)
	other_user = insert(:user)
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, a1} = CommonAPI.post(user1, %{status: "bla"})
	{:ok, _a2} = CommonAPI.post(user2, %{status: "traps are happy"})
	{:ok, a3} = CommonAPI.post(user2, %{status: "Trees Are "})
	{:ok, a4} = CommonAPI.post(user2, %{status: "Agent Smith "})
	{:ok, a5} = CommonAPI.post(user1, %{status: "Red or Blue "})

	{:ok, _} = CommonAPI.favorite(a4.id, user)
	{:ok, _} = CommonAPI.favorite(a3.id, other_user)
	{:ok, _} = CommonAPI.favorite(a3.id, user)
	{:ok, _} = CommonAPI.favorite(a5.id, other_user)
	{:ok, _} = CommonAPI.favorite(a5.id, user)
	{:ok, _} = CommonAPI.favorite(a4.id, other_user)
	{:ok, _} = CommonAPI.favorite(a1.id, user)
	{:ok, _} = CommonAPI.favorite(a1.id, other_user)
	result = ActivityPub.fetch_favourites(user)

	assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]

	result = ActivityPub.fetch_favourites(user, %{limit: 2})
	assert Enum.map(result, & &1.id) == [a1.id, a5.id]
	end
	end

	describe "Move activity" do
	test "create" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	follower_move_opted_out = insert(:user, allow_following_move: false)

	User.follow(follower, old_user)
	User.follow(follower_move_opted_out, old_user)

	assert User.following?(follower, old_user)
	assert User.following?(follower_move_opted_out, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true,
	recipients: recipients
	} = activity

	assert old_user.follower_address in recipients

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	refute User.following?(follower, old_user)
	assert User.following?(follower, new_user)

	assert User.following?(follower_move_opted_out, old_user)
	refute User.following?(follower_move_opted_out, new_user)

	activity = %Activity{activity \| object: nil}

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower)

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
	end

	test "old user must be in the new user's `also_known_as` list" do
	old_user = insert(:user)
	new_user = insert(:user)

	assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
	ActivityPub.move(old_user, new_user)
	end

	test "do not move remote user following relationships" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower_remote = insert(:user, local: false)

	User.follow(follower_remote, old_user)

	assert User.following?(follower_remote, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true
	} = activity

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	assert User.following?(follower_remote, old_user)
	refute User.following?(follower_remote, new_user)
	end
	end

	test "doesn't retrieve replies activities with exclude_replies" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})

	{:ok, _reply} = CommonAPI.post(user, %{status: "yeah", in_reply_to_status_id: activity.id})

	[result] = ActivityPub.fetch_public_activities(%{exclude_replies: true})

	assert result.id == activity.id

	assert length(ActivityPub.fetch_public_activities()) == 2
	end

	describe "replies filtering with public messages" do
	setup :public_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 16
	end

	test "public timeline with reply_visibility `following`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 14

	visible_ids =
	Map.values(u1) ++ Map.values(u2) ++ Map.values(u4) ++ Map.values(activities) ++ [u3[:r1]]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "public timeline with reply_visibility `self`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10
	visible_ids = Map.values(u1) ++ [u2[:r1], u3[:r1], u4[:r1]] ++ Map.values(activities)
	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 13

	visible_ids =
	Map.values(u1) ++
	Map.values(u3) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `following`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 11

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u3[:r1],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 9

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u3[:r1],
	u4[:r1]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "filtering out announces where the user is the actor of the announced message" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	User.follow(user, other_user)

	{:ok, post} = CommonAPI.post(user, %{status: "yo"})
	{:ok, other_post} = CommonAPI.post(third_user, %{status: "yo"})
	{:ok, _announce} = CommonAPI.repeat(post.id, other_user)
	{:ok, _announce} = CommonAPI.repeat(post.id, third_user)
	{:ok, announce} = CommonAPI.repeat(other_post.id, other_user)

	params = %{
	type: ["Announce"]
	}

	results =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert length(results) == 3

	params = %{
	type: ["Announce"],
	announce_filtering_user: user
	}

	[result] =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert result.id == announce.id
	end
	end

	describe "replies filtering with private messages" do
	setup :private_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `self`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []

	activities_ids =
	%{}
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, nil)
	\|> ActivityPub.fetch_public_activities()

	assert activities_ids == []
	end

	test "home timeline", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10

	visible_ids =
	Map.values(u1) ++ Map.values(u4) ++ [u2[:r1], u3[:r1]] ++ Map.values(activities)

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end
	end

	defp public_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_3} =
	CommonAPI.post(u4, %{
	status: "@#{u2.nickname} reply from u4 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_3} =
	CommonAPI.post(u4, %{
	status: "@#{u3.nickname} reply from u4 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_2} =
	CommonAPI.post(u2, %{
	status: "@#{u4.nickname} reply from u2 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_3} =
	CommonAPI.post(u3, %{
	status: "@#{u4.nickname} reply from u3 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id, r3: r2_3.id},
	u3: %{r1: r3_1.id, r2: r3_2.id, r3: r3_3.id},
	u4: %{r1: r4_1.id, r2: r4_2.id, r3: r4_3.id}}
	end

	defp private_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u3} = User.follow(u1, u3)
	{:ok, u3, u1} = User.follow(u3, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status", visibility: "private"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status", visibility: "private"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status", visibility: "private"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status", visibility: "private"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id,
	visibility: "private"
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id},
	u3: %{r1: r3_1.id, r2: r3_2.id},
	u4: %{r1: r4_1.id}}
	end

	describe "maybe_update_follow_information/1" do
	setup do
	clear_config([:instance, :external_user_synchronization], true)

	user = %{
	local: false,
	ap_id: "https://gensokyo.2hu/users/raymoo",
	following_address: "https://gensokyo.2hu/users/following",
	follower_address: "https://gensokyo.2hu/users/followers",
	type: "Person"
	}

	%{user: user}
	end

	test "logs an error when it can't fetch the info", %{user: user} do
	assert capture_log(fn ->
	ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "just returns the input if the user type is Application", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:type, "Application")

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "it just returns the input if the user has no following/follower addresses", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:following_address, nil)
	\|> Map.put(:follower_address, nil)

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end
	end

	describe "global activity expiration" do
	test "creates an activity expiration for local Create activities" do
	clear_config([:mrf, :policies], Pleroma.Web.ActivityPub.MRF.ActivityExpirationPolicy)

	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, follow} = ActivityBuilder.insert(%{"type" => "Follow", "context" => "3hu"})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id},
	scheduled_at:
	activity.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	refute_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: follow.id}
	)
	end
	end

	describe "handling of clashing nicknames" do
	test "renames an existing user with a clashing nickname and a different ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id <> "part_2"
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == "#{orig_user.id}.admin@mastodon.example.org"
	end

	test "does nothing with a clashing nickname and the same ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == orig_user.nickname
	end
	end

	describe "reply filtering" do
	test "`following` still contains announcements by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})

	{:ok, not_followed_to_followed} =
	CommonAPI.post(not_followed, %{
	status: "Also hello",
	in_reply_to_status_id: followed_post.id
	})

	{:ok, retoot} = CommonAPI.repeat(not_followed_to_followed.id, followed)

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

	activities =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	followed_post_id = followed_post.id
	retoot_id = retoot.id

	assert [%{id: ^followed_post_id}, %{id: ^retoot_id}] = activities

	assert length(activities) == 2
	end

	# This test is skipped because, while this is the desired behavior,
	# there seems to be no good way to achieve it with the method that
	# we currently use for detecting to who a reply is directed.
	# This is a TODO and should be fixed by a later rewrite of the code
	# in question.
	@tag skip: true
	test "`following` still contains self-replies by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})
	{:ok, not_followed_post} = CommonAPI.post(not_followed, %{status: "Also hello"})

	{:ok, _followed_to_not_followed} =
	CommonAPI.post(followed, %{status: "sup", in_reply_to_status_id: not_followed_post.id})

	{:ok, _followed_self_reply} =
	CommonAPI.post(followed, %{status: "Also cofe", in_reply_to_status_id: followed_post.id})

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

	activities =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert length(activities) == 2
	end
	end

	test "allow fetching of accounts with an empty string name field" do
	Tesla.Mock.mock(fn
	%{method: :get, url: "https://princess.cat/users/mewmew"} ->
	file = File.read!("test/fixtures/mewmew_no_name.json")
	%Tesla.Env{status: 200, body: file, headers: HttpRequestMock.activitypub_object_headers()}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id("https://princess.cat/users/mewmew")
	assert user.name == " "
	end

	test "pin_data_from_featured_collection will ignore unsupported values" do
	assert %{} ==
	ActivityPub.pin_data_from_featured_collection(%{
	"type" => "OrderedCollection",
	"first" => "https://social.example/users/alice/collections/featured?page=true"
	})
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 11:55 AM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723153
Default Alt Text: (220 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions