No OneTemporary
Actions

Size

128 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 0431d62af..e5f265817 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,853 +1,865 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPub do
	alias Pleroma.{Activity, Repo, Object, Upload, User, Notification}
	alias Pleroma.Web.ActivityPub.{Transmogrifier, MRF}
	alias Pleroma.Web.WebFinger
	alias Pleroma.Web.Federator
	alias Pleroma.Web.OStatus
	import Ecto.Query
	import Pleroma.Web.ActivityPub.Utils
	require Logger

	@httpoison Application.get_env(:pleroma, :httpoison)

	# For Announce activities, we filter the recipients based on following status for any actors
	# that match actual users. See issue #164 for more information about why this is necessary.
	defp get_recipients(%{"type" => "Announce"} = data) do
	to = data["to"] \|\| []
	cc = data["cc"] \|\| []
	recipients = to ++ cc
	actor = User.get_cached_by_ap_id(data["actor"])

	recipients
	\|> Enum.filter(fn recipient ->
	case User.get_cached_by_ap_id(recipient) do
	nil ->
	true

	user ->
	User.following?(user, actor)
	end
	end)

	{recipients, to, cc}
	end

	defp get_recipients(data) do
	to = data["to"] \|\| []
	cc = data["cc"] \|\| []
	recipients = to ++ cc
	{recipients, to, cc}
	end

	defp check_actor_is_active(actor) do
	if not is_nil(actor) do
	with user <- User.get_cached_by_ap_id(actor),
	false <- user.info.deactivated do
	:ok
	else
	_e -> :reject
	end
	else
	:ok
	end
	end

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

	defp check_remote_limit(_), do: true

	def insert(map, local \\ true) when is_map(map) do
	with nil <- Activity.normalize(map),
	map <- lazy_put_activity_defaults(map),
	:ok <- check_actor_is_active(map["actor"]),
	{_, true} <- {:remote_limit_error, check_remote_limit(map)},
	{:ok, map} <- MRF.filter(map),
	:ok <- insert_full_object(map) do
	{recipients, _, _} = get_recipients(map)

	{:ok, activity} =
	Repo.insert(%Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients
	})

	Notification.create_notifications(activity)
	stream_out(activity)
	{:ok, activity}
	else
	%Activity{} = activity -> {:ok, activity}
	error -> {:error, error}
	end
	end

	def stream_out(activity) do
	public = "https://www.w3.org/ns/activitystreams#Public"

	if activity.data["type"] in ["Create", "Announce", "Delete"] do
	Pleroma.Web.Streamer.stream("user", activity)
	Pleroma.Web.Streamer.stream("list", activity)

	if Enum.member?(activity.data["to"], public) do
	Pleroma.Web.Streamer.stream("public", activity)

	if activity.local do
	Pleroma.Web.Streamer.stream("public:local", activity)
	end

	if activity.data["type"] in ["Create"] do
	activity.data["object"]
	\|> Map.get("tag", [])
	\|> Enum.filter(fn tag -> is_bitstring(tag) end)
	\|> Enum.map(fn tag -> Pleroma.Web.Streamer.stream("hashtag:" <> tag, activity) end)

	if activity.data["object"]["attachment"] != [] do
	Pleroma.Web.Streamer.stream("public:media", activity)

	if activity.local do
	Pleroma.Web.Streamer.stream("public:local:media", activity)
	end
	end
	end
	else
	if !Enum.member?(activity.data["cc"] \|\| [], public) &&
	!Enum.member?(
	activity.data["to"],
	User.get_by_ap_id(activity.data["actor"]).follower_address
	),
	do: Pleroma.Web.Streamer.stream("direct", activity)
	end
	end
	end

	def create(%{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]

	with create_data <-
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	),
	{:ok, activity} <- insert(create_data, local),
	:ok <- maybe_federate(activity),
	{:ok, _actor} <- User.increase_note_count(actor) do
	{:ok, activity}
	end
	end

	def accept(%{to: to, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{"to" => to, "type" => "Accept", "actor" => actor, "object" => object},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def reject(%{to: to, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{"to" => to, "type" => "Reject", "actor" => actor, "object" => object},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{
	"to" => to,
	"cc" => cc,
	"type" => "Update",
	"actor" => actor,
	"object" => object
	},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	# TODO: This is weird, maybe we shouldn't check here if we can make the activity.
	def like(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with nil <- get_existing_like(ap_id, object),
	like_data <- make_like_data(user, object, activity_id),
	{:ok, activity} <- insert(like_data, local),
	{:ok, object} <- add_like_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	%Activity{} = activity -> {:ok, activity, object}
	error -> {:error, error}
	end
	end

	def unlike(
	%User{} = actor,
	%Object{} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
	unlike_data <- make_unlike_data(actor, like_activity, activity_id),
	{:ok, unlike_activity} <- insert(unlike_data, local),
	{:ok, _activity} <- Repo.delete(like_activity),
	{:ok, object} <- remove_like_from_object(like_activity, object),
	:ok <- maybe_federate(unlike_activity) do
	{:ok, unlike_activity, like_activity, object}
	else
	_e -> {:ok, object}
	end
	end

	def announce(
	%User{ap_id: _} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true,
	public \\ true
	) do
	with true <- is_public?(object),
	announce_data <- make_announce_data(user, object, activity_id, public),
	{:ok, activity} <- insert(announce_data, local),
	{:ok, object} <- add_announce_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	error -> {:error, error}
	end
	end

	def unannounce(
	%User{} = actor,
	%Object{} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
	unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
	{:ok, unannounce_activity} <- insert(unannounce_data, local),
	:ok <- maybe_federate(unannounce_activity),
	{:ok, _activity} <- Repo.delete(announce_activity),
	{:ok, object} <- remove_announce_from_object(announce_activity, object) do
	{:ok, unannounce_activity, object}
	else
	_e -> {:ok, object}
	end
	end

	def follow(follower, followed, activity_id \\ nil, local \\ true) do
	with data <- make_follow_data(follower, followed, activity_id),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def unfollow(follower, followed, activity_id \\ nil, local \\ true) 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),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
	user = User.get_cached_by_ap_id(actor)

	data = %{
	"type" => "Delete",
	"actor" => actor,
	"object" => id,
	"to" => [user.follower_address, "https://www.w3.org/ns/activitystreams#Public"]
	}

	with {:ok, _} <- Object.delete(object),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity),
	{:ok, _actor} <- User.decrease_note_count(user) do
	{:ok, activity}
	end
	end

	def block(blocker, blocked, activity_id \\ nil, local \\ true) do
	ap_config = Application.get_env(:pleroma, :activitypub)
	unfollow_blocked = Keyword.get(ap_config, :unfollow_blocked)
	outgoing_blocks = Keyword.get(ap_config, :outgoing_blocks)

	with true <- unfollow_blocked do
	follow_activity = fetch_latest_follow(blocker, blocked)

	if follow_activity do
	unfollow(blocker, blocked, nil, local)
	end
	end

	with true <- outgoing_blocks,
	block_data <- make_block_data(blocker, blocked, activity_id),
	{:ok, activity} <- insert(block_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	_e -> {:ok, nil}
	end
	end

	def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
	with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
	unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
	{:ok, activity} <- insert(unblock_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def fetch_activities_for_context(context, opts \\ %{}) do
	public = ["https://www.w3.org/ns/activitystreams#Public"]

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

	query = from(activity in Activity)

	query =
	query
	\|> restrict_blocked(opts)
	\|> restrict_recipients(recipients, opts["user"])

	query =
	from(
	activity in query,
	where:
	fragment(
	"?->>'type' = ? and ?->>'context' = ?",
	activity.data,
	"Create",
	activity.data,
	^context
	),
	order_by: [desc: :id]
	)

	Repo.all(query)
	end

	def fetch_public_activities(opts \\ %{}) do
	q = fetch_activities_query(["https://www.w3.org/ns/activitystreams#Public"], opts)

	q
	\|> restrict_unlisted()
	\|> Repo.all()
	\|> Enum.reverse()
	end

	@valid_visibilities ~w[direct unlisted public private]

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

	Ecto.Adapters.SQL.to_sql(:all, Repo, query)

	query
	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

	def fetch_user_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("actor_id", user.ap_id)
	\|> Map.put("whole_db", true)
	\|> Map.put("pinned_activity_ids", user.info.pinned_activities)

	recipients =
	if reading_user do
	["https://www.w3.org/ns/activitystreams#Public"] ++
	[reading_user.ap_id \| reading_user.following]
	else
	["https://www.w3.org/ns/activitystreams#Public"]
	end

	fetch_activities(recipients, params)
	\|> Enum.reverse()
	end

	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_tag(query, %{"tag" => tag}) do
	from(
	activity in query,
	where: fragment("? <@ (? #> '{\"object\",\"tag\"}')", ^tag, activity.data)
	)
	end

	defp restrict_tag(query, _), do: query

	defp restrict_to_cc(query, recipients_to, recipients_cc) do
	from(
	activity in query,
	where:
	fragment(
	"(?->'to' \\?\| ?) or (?->'cc' \\?\| ?)",
	activity.data,
	^recipients_to,
	activity.data,
	^recipients_cc
	)
	)
	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_limit(query, %{"limit" => limit}) do
	from(activity in query, limit: ^limit)
	end

	defp restrict_limit(query, _), do: query

	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_max(query, %{"max_id" => max_id}) do
	from(activity in query, where: activity.id < ^max_id)
	end

	defp restrict_max(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
	restrict_type(query, %{"type" => [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_favorited_by(query, %{"favorited_by" => ap_id}) do
	from(
	activity in query,
	where: fragment("? <@ (? #> '{\"object\",\"likes\"}')", ^ap_id, activity.data)
	)
	end

	defp restrict_favorited_by(query, _), do: query

	defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
	from(
	activity in query,
	where: fragment("not (? #> '{\"object\",\"attachment\"}' = ?)", activity.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

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

	defp restrict_replies(query, _), do: query

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

	defp restrict_reblogs(query, _), do: query

	defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
	blocks = info.blocks \|\| []
	domain_blocks = info.domain_blocks \|\| []

	from(
	activity in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
	where: fragment("not (?->'to' \\?\| ?)", activity.data, ^blocks),
	where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks)
	)
	end

	defp restrict_blocked(query, _), do: query

	defp restrict_unlisted(query) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^["https://www.w3.org/ns/activitystreams#Public"]
	)
	)
	end

	defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
	from(activity in query, where: activity.id in ^ids)
	end

	defp restrict_pinned(query, _), do: query

	def fetch_activities_query(recipients, opts \\ %{}) do
	base_query =
	from(
	activity in Activity,
	limit: 20,
	order_by: [fragment("? desc nulls last", activity.id)]
	)

	base_query
	\|> restrict_recipients(recipients, opts["user"])
	\|> restrict_tag(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_limit(opts)
	\|> restrict_max(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_replies(opts)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	end

	def fetch_activities(recipients, opts \\ %{}) do
	fetch_activities_query(recipients, opts)
	\|> Repo.all()
	\|> Enum.reverse()
	end

	def fetch_activities_bounded(recipients_to, recipients_cc, opts \\ %{}) do
	fetch_activities_query([], opts)
	\|> restrict_to_cc(recipients_to, recipients_cc)
	\|> Repo.all()
	\|> Enum.reverse()
	end

	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(file, opts) do
	obj_data =
	if opts[:actor] do
	Map.put(data, "actor", opts[:actor])
	else
	data
	end

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

	def user_data_from_user_object(data) do
	avatar =
	data["icon"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["icon"]["url"]}]
	}

	banner =
	data["image"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["image"]["url"]}]
	}

	locked = data["manuallyApprovesFollowers"] \|\| false
	data = Transmogrifier.maybe_fix_user_object(data)

	user_data = %{
	ap_id: data["id"],
	info: %{
	"ap_enabled" => true,
	"source_data" => data,
	"banner" => banner,
	"locked" => locked
	},
	avatar: avatar,
	name: data["name"],
	follower_address: data["followers"],
	bio: data["summary"]
	}

	# nickname can be nil because of virtual actors
	user_data =
	if data["preferredUsername"] do
	Map.put(
	user_data,
	:nickname,
	"#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
	)
	else
	Map.put(user_data, :nickname, nil)
	end

	{:ok, user_data}
	end

	def fetch_and_prepare_user_from_ap_id(ap_id) do
	with {:ok, data} <- fetch_and_contain_remote_object_from_id(ap_id) do
	user_data_from_user_object(data)
	else
	e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	end
	end

	def make_user_from_ap_id(ap_id) do
	if _user = User.get_by_ap_id(ap_id) do
	Transmogrifier.upgrade_user_from_ap_id(ap_id)
	else
	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
	User.insert_or_update_user(data)
	else
	e -> {:error, e}
	end
	end
	end

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

	def should_federate?(inbox, public) do
	if public do
	true
	else
	inbox_info = URI.parse(inbox)
	!Enum.member?(Pleroma.Config.get([:instance, :quarantined_instances], []), inbox_info.host)
	end
	end

	def publish(actor, activity) do
	followers =
	if actor.follower_address in activity.recipients do
	{:ok, followers} = User.get_followers(actor)
	followers \|> Enum.filter(&(!&1.local))
	else
	[]
	end

	public = is_public?(activity)

	remote_inboxes =
	(Pleroma.Web.Salmon.remote_users(activity) ++ followers)
	\|> Enum.filter(fn user -> User.ap_enabled?(user) end)
	\|> Enum.map(fn %{info: %{source_data: data}} ->
	(is_map(data["endpoints"]) && Map.get(data["endpoints"], "sharedInbox")) \|\| data["inbox"]
	end)
	\|> Enum.uniq()
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)

	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
	json = Jason.encode!(data)

	Enum.each(remote_inboxes, fn inbox ->
	Federator.enqueue(:publish_single_ap, %{
	inbox: inbox,
	json: json,
	actor: actor,
	id: activity.data["id"]
	})
	end)
	end

	def publish_one(%{inbox: inbox, json: json, actor: actor, id: id}) do
	Logger.info("Federating #{id} to #{inbox}")
	host = URI.parse(inbox).host

	digest = "SHA-256=" <> (:crypto.hash(:sha256, json) \|> Base.encode64())

	signature =
	Pleroma.Web.HTTPSignatures.sign(actor, %{
	host: host,
	"content-length": byte_size(json),
	digest: digest
	})

	@httpoison.post(
	inbox,
	json,
	[
	{"Content-Type", "application/activity+json"},
	{"signature", signature},
	{"digest", digest}
	]
	)
	end

	# TODO:
	# This will create a Create activity, which we need internally at the moment.
	def fetch_object_from_id(id) do
	if object = Object.get_cached_by_ap_id(id) do
	{:ok, object}
	else
	Logger.info("Fetching #{id} via AP")

	with {:ok, data} <- fetch_and_contain_remote_object_from_id(id),
	nil <- Object.normalize(data),
	params <- %{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => data["actor"] \|\| data["attributedTo"],
	"object" => data
	},
	:ok <- Transmogrifier.contain_origin(id, params),
	{:ok, activity} <- Transmogrifier.handle_incoming(params) do
	{:ok, Object.normalize(activity.data["object"])}
	else
	{:error, {:reject, nil}} ->
	{:reject, nil}

	object = %Object{} ->
	{:ok, object}

	_e ->
	Logger.info("Couldn't get object via AP, trying out OStatus fetching...")

	case OStatus.fetch_activity_from_url(id) do
	{:ok, [activity \| _]} -> {:ok, Object.normalize(activity.data["object"])}
	e -> e
	end
	end
	end
	end

	def fetch_and_contain_remote_object_from_id(id) do
	Logger.info("Fetching #{id} via AP")

	with true <- String.starts_with?(id, "http"),
	{:ok, %{body: body, status: code}} when code in 200..299 <-
	@httpoison.get(
	id,
	[{:Accept, "application/activity+json"}]
	),
	{:ok, data} <- Jason.decode(body),
	:ok <- Transmogrifier.contain_origin_from_id(id, data) do
	{:ok, data}
	else
	e ->
	{:error, e}
	end
	end

	def is_public?(%Object{data: %{"type" => "Tombstone"}}), do: false
	def is_public?(%Object{data: data}), do: is_public?(data)
	def is_public?(%Activity{data: data}), do: is_public?(data)
	+ def is_public?(%{"directMessage" => true}), do: false

	def is_public?(data) do
	"https://www.w3.org/ns/activitystreams#Public" in (data["to"] ++ (data["cc"] \|\| []))
	end

	+ def is_private?(activity) do
	+ !is_public?(activity) && Enum.any?(activity.data["to"], &String.contains?(&1, "/followers"))
	+ end
	+
	+ def is_direct?(%Activity{data: %{"directMessage" => true}}), do: true
	+ def is_direct?(%Object{data: %{"directMessage" => true}}), do: true
	+
	+ def is_direct?(activity) do
	+ !is_public?(activity) && !is_private?(activity)
	+ end
	+
	def visible_for_user?(activity, nil) do
	is_public?(activity)
	end

	def visible_for_user?(activity, user) do
	x = [user.ap_id \| user.following]
	y = activity.data["to"] ++ (activity.data["cc"] \|\| [])
	visible_for_user?(activity, nil) \|\| Enum.any?(x, &(&1 in y))
	end

	# guard
	def entire_thread_visible_for_user?(nil, _user), do: false

	# child
	def entire_thread_visible_for_user?(
	%Activity{data: %{"object" => %{"inReplyTo" => parent_id}}} = tail,
	user
	)
	when is_binary(parent_id) do
	parent = Activity.get_in_reply_to_activity(tail)
	visible_for_user?(tail, user) && entire_thread_visible_for_user?(parent, user)
	end

	# root
	def entire_thread_visible_for_user?(tail, user), do: visible_for_user?(tail, user)

	# filter out broken threads
	def 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

	# do post-processing on a timeline
	def contain_timeline(timeline, user) do
	timeline
	\|> Enum.filter(fn activity ->
	contain_activity(activity, user)
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index fa3abe3d8..5d3feccfe 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,943 +1,979 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier do
	@moduledoc """
	A module to handle coding from internal to wire ActivityPub and back.
	"""
	alias Pleroma.User
	alias Pleroma.Object
	alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils

	import Ecto.Query

	require Logger

	def get_actor(%{"actor" => actor}) when is_binary(actor) do
	actor
	end

	def get_actor(%{"actor" => actor}) when is_list(actor) do
	if is_binary(Enum.at(actor, 0)) do
	Enum.at(actor, 0)
	else
	Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
	\|> Map.get("id")
	end
	end

	def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
	id
	end

	def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
	get_actor(%{"actor" => actor})
	end

	@doc """
	Checks that an imported AP object's actor matches the domain it came from.
	"""
	def contain_origin(_id, %{"actor" => nil}), do: :error

	def contain_origin(id, %{"actor" => _actor} = params) do
	id_uri = URI.parse(id)
	actor_uri = URI.parse(get_actor(params))

	if id_uri.host == actor_uri.host do
	:ok
	else
	:error
	end
	end

	def contain_origin_from_id(_id, %{"id" => nil}), do: :error

	def contain_origin_from_id(id, %{"id" => other_id} = _params) do
	id_uri = URI.parse(id)
	other_uri = URI.parse(other_id)

	if id_uri.host == other_uri.host do
	:ok
	else
	:error
	end
	end

	@doc """
	Modifies an incoming AP object (mastodon format) to our internal format.
	"""
	def fix_object(object) do
	object
	\|> fix_actor
	\|> fix_url
	\|> fix_attachments
	\|> fix_context
	\|> fix_in_reply_to
	\|> fix_emoji
	\|> fix_tag
	\|> fix_content_map
	\|> fix_likes
	\|> fix_addressing
	end

	def fix_addressing_list(map, field) do
	if is_binary(map[field]) do
	map
	\|> Map.put(field, [map[field]])
	else
	map
	end
	end

	- def fix_addressing(map) do
	- map
	+ def fix_explicit_addressing(%{"to" => to, "cc" => cc} = object, explicit_mentions) do
	+ explicit_to =
	+ to
	+ \|> Enum.filter(fn x -> x in explicit_mentions end)
	+
	+ explicit_cc =
	+ to
	+ \|> Enum.filter(fn x -> x not in explicit_mentions end)
	+
	+ final_cc =
	+ (cc ++ explicit_cc)
	+ \|> Enum.uniq()
	+
	+ object
	+ \|> Map.put("to", explicit_to)
	+ \|> Map.put("cc", final_cc)
	+ end
	+
	+ def fix_explicit_addressing(object, _explicit_mentions), do: object
	+
	+ # if directMessage flag is set to true, leave the addressing alone
	+ def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
	+
	+ def fix_explicit_addressing(object) do
	+ explicit_mentions =
	+ object
	+ \|> Utils.determine_explicit_mentions()
	+
	+ explicit_mentions = explicit_mentions ++ ["https://www.w3.org/ns/activitystreams#Public"]
	+
	+ object
	+ \|> fix_explicit_addressing(explicit_mentions)
	+ end
	+
	+ def fix_addressing(object) do
	+ object
	\|> fix_addressing_list("to")
	\|> fix_addressing_list("cc")
	\|> fix_addressing_list("bto")
	\|> fix_addressing_list("bcc")
	+ \|> fix_explicit_addressing
	end

	def fix_actor(%{"attributedTo" => actor} = object) do
	object
	\|> Map.put("actor", get_actor(%{"actor" => actor}))
	end

	def fix_likes(%{"likes" => likes} = object)
	when is_bitstring(likes) do
	# Check for standardisation
	# This is what Peertube does
	# curl -H 'Accept: application/activity+json' $likes \| jq .totalItems
	object
	\|> Map.put("likes", [])
	\|> Map.put("like_count", 0)
	end

	def fix_likes(object) do
	object
	end

	def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object)
	when not is_nil(in_reply_to) do
	in_reply_to_id =
	cond do
	is_bitstring(in_reply_to) ->
	in_reply_to

	is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
	in_reply_to["id"]

	is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
	Enum.at(in_reply_to, 0)

	# Maybe I should output an error too?
	true ->
	""
	end

	case fetch_obj_helper(in_reply_to_id) do
	{:ok, replied_object} ->
	with %Activity{} = activity <-
	Activity.get_create_activity_by_object_ap_id(replied_object.data["id"]) do
	object
	\|> Map.put("inReplyTo", replied_object.data["id"])
	\|> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] \|\| in_reply_to_id)
	\|> Map.put("inReplyToStatusId", activity.id)
	\|> Map.put("conversation", replied_object.data["context"] \|\| object["conversation"])
	\|> Map.put("context", replied_object.data["context"] \|\| object["conversation"])
	else
	e ->
	Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
	object
	end

	e ->
	Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
	object
	end
	end

	def fix_in_reply_to(object), do: object

	def fix_context(object) do
	context = object["context"] \|\| object["conversation"] \|\| Utils.generate_context_id()

	object
	\|> Map.put("context", context)
	\|> Map.put("conversation", context)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
	attachments =
	attachment
	\|> Enum.map(fn data ->
	media_type = data["mediaType"] \|\| data["mimeType"]
	href = data["url"] \|\| data["href"]

	url = [%{"type" => "Link", "mediaType" => media_type, "href" => href}]

	data
	\|> Map.put("mediaType", media_type)
	\|> Map.put("url", url)
	end)

	object
	\|> Map.put("attachment", attachments)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
	Map.put(object, "attachment", [attachment])
	\|> fix_attachments()
	end

	def fix_attachments(object), do: object

	def fix_url(%{"url" => url} = object) when is_map(url) do
	object
	\|> Map.put("url", url["href"])
	end

	def fix_url(%{"type" => "Video", "url" => url} = object) when is_list(url) do
	first_element = Enum.at(url, 0)

	link_element =
	url
	\|> Enum.filter(fn x -> is_map(x) end)
	\|> Enum.filter(fn x -> x["mimeType"] == "text/html" end)
	\|> Enum.at(0)

	object
	\|> Map.put("attachment", [first_element])
	\|> Map.put("url", link_element["href"])
	end

	def fix_url(%{"type" => object_type, "url" => url} = object)
	when object_type != "Video" and is_list(url) do
	first_element = Enum.at(url, 0)

	url_string =
	cond do
	is_bitstring(first_element) -> first_element
	is_map(first_element) -> first_element["href"] \|\| ""
	true -> ""
	end

	object
	\|> Map.put("url", url_string)
	end

	def fix_url(object), do: object

	def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
	emoji = tags \|> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)

	emoji =
	emoji
	\|> Enum.reduce(%{}, fn data, mapping ->
	name = String.trim(data["name"], ":")

	mapping \|> Map.put(name, data["icon"]["url"])
	end)

	# we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
	emoji = Map.merge(object["emoji"] \|\| %{}, emoji)

	object
	\|> Map.put("emoji", emoji)
	end

	def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
	name = String.trim(tag["name"], ":")
	emoji = %{name => tag["icon"]["url"]}

	object
	\|> Map.put("emoji", emoji)
	end

	def fix_emoji(object), do: object

	def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
	tags =
	tag
	\|> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
	\|> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)

	combined = tag ++ tags

	object
	\|> Map.put("tag", combined)
	end

	def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
	combined = [tag, String.slice(hashtag, 1..-1)]

	object
	\|> Map.put("tag", combined)
	end

	def fix_tag(object), do: object

	# content map usually only has one language so this will do for now.
	def fix_content_map(%{"contentMap" => content_map} = object) do
	content_groups = Map.to_list(content_map)
	{_, content} = Enum.at(content_groups, 0)

	object
	\|> Map.put("content", content)
	end

	def fix_content_map(object), do: object

	defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
	with true <- id =~ "follows",
	%User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
	%Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
	{:ok, activity}
	else
	_ -> {:error, nil}
	end
	end

	defp mastodon_follow_hack(_, _), do: {:error, nil}

	defp get_follow_activity(follow_object, followed) do
	with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
	{_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
	{:ok, activity}
	else
	# Can't find the activity. This might a Mastodon 2.3 "Accept"
	{:activity, nil} ->
	mastodon_follow_hack(follow_object, followed)

	_ ->
	{:error, nil}
	end
	end

	# disallow objects with bogus IDs
	def handle_incoming(%{"id" => nil}), do: :error
	def handle_incoming(%{"id" => ""}), do: :error
	# length of https:// = 8, should validate better, but good enough for now.
	def handle_incoming(%{"id" => id}) when not (is_binary(id) and length(id) > 8), do: :error

	# TODO: validate those with a Ecto scheme
	# - tags
	# - emoji
	def handle_incoming(%{"type" => "Create", "object" => %{"type" => objtype} = object} = data)
	when objtype in ["Article", "Note", "Video", "Page"] do
	actor = get_actor(data)

	data =
	Map.put(data, "actor", actor)
	\|> fix_addressing

	with nil <- Activity.get_create_activity_by_object_ap_id(object["id"]),
	%User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
	object = fix_object(data["object"])

	params = %{
	to: data["to"],
	object: object,
	actor: user,
	context: object["conversation"],
	local: false,
	published: data["published"],
	additional:
	Map.take(data, [
	"cc",
	+ "directMessage",
	"id"
	])
	}

	ActivityPub.create(params)
	else
	%Activity{} = activity -> {:ok, activity}
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
	) do
	with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	%User{} = follower <- User.get_or_fetch_by_ap_id(follower),
	{:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
	if not User.locked?(followed) do
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed.ap_id,
	object: data,
	local: true
	})

	User.follow(follower, followed)
	end

	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data
	) do
	with actor <- get_actor(data),
	%User{} = followed <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, activity} <-
	ActivityPub.accept(%{
	to: follow_activity.data["to"],
	type: "Accept",
	actor: followed.ap_id,
	object: follow_activity.data["id"],
	local: false
	}) do
	if not User.following?(follower, followed) do
	{:ok, _follower} = User.follow(follower, followed)
	end

	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data
	) do
	with actor <- get_actor(data),
	%User{} = followed <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, activity} <-
	ActivityPub.accept(%{
	to: follow_activity.data["to"],
	type: "Accept",
	actor: followed.ap_id,
	object: follow_activity.data["id"],
	local: false
	}) do
	User.unfollow(follower, followed)

	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data
	) do
	with actor <- get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	{:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data
	) do
	with actor <- get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	public <- ActivityPub.is_public?(data),
	{:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
	data
	)
	when object_type in ["Person", "Application", "Service", "Organization"] do
	with %User{ap_id: ^actor_id} = actor <- User.get_by_ap_id(object["id"]) do
	{:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)

	banner = new_user_data[:info]["banner"]
	locked = new_user_data[:info]["locked"] \|\| false

	update_data =
	new_user_data
	\|> Map.take([:name, :bio, :avatar])
	\|> Map.put(:info, %{"banner" => banner, "locked" => locked})

	actor
	\|> User.upgrade_changeset(update_data)
	\|> User.update_and_set_cache()

	ActivityPub.update(%{
	local: false,
	to: data["to"] \|\| [],
	cc: data["cc"] \|\| [],
	object: object,
	actor: actor_id
	})
	else
	e ->
	Logger.error(e)
	:error
	end
	end

	# TODO: We presently assume that any actor on the same origin domain as the object being
	# deleted has the rights to delete that object. A better way to validate whether or not
	# the object should be deleted is to refetch the object URI, which should return either
	# an error or a tombstone. This would allow us to verify that a deletion actually took
	# place.
	def handle_incoming(
	%{"type" => "Delete", "object" => object_id, "actor" => _actor, "id" => _id} = data
	) do
	object_id = Utils.get_ap_id(object_id)

	with actor <- get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	:ok <- contain_origin(actor.ap_id, object.data),
	{:ok, activity} <- ActivityPub.delete(object, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Announce", "object" => object_id},
	"actor" => _actor,
	"id" => id
	} = data
	) do
	with actor <- get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	{:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "object" => followed},
	"actor" => follower,
	"id" => id
	} = _data
	) do
	with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	%User{} = follower <- User.get_or_fetch_by_ap_id(follower),
	{:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
	User.unfollow(follower, followed)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Block", "object" => blocked},
	"actor" => blocker,
	"id" => id
	} = _data
	) do
	with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
	%User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
	%User{} = blocker <- User.get_or_fetch_by_ap_id(blocker),
	{:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
	User.unblock(blocker, blocked)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data
	) do
	with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
	%User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
	%User{} = blocker = User.get_or_fetch_by_ap_id(blocker),
	{:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
	User.unfollow(blocker, blocked)
	User.block(blocker, blocked)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Like", "object" => object_id},
	"actor" => _actor,
	"id" => id
	} = data
	) do
	with actor <- get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	{:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(_), do: :error

	def fetch_obj_helper(id) when is_bitstring(id), do: ActivityPub.fetch_object_from_id(id)
	def fetch_obj_helper(obj) when is_map(obj), do: ActivityPub.fetch_object_from_id(obj["id"])

	def get_obj_helper(id) do
	if object = Object.normalize(id), do: {:ok, object}, else: nil
	end

	def set_reply_to_uri(%{"inReplyTo" => inReplyTo} = object) do
	with false <- String.starts_with?(inReplyTo, "http"),
	{:ok, %{data: replied_to_object}} <- get_obj_helper(inReplyTo) do
	Map.put(object, "inReplyTo", replied_to_object["external_url"] \|\| inReplyTo)
	else
	_e -> object
	end
	end

	def set_reply_to_uri(obj), do: obj

	# Prepares the object of an outgoing create activity.
	def prepare_object(object) do
	object
	\|> set_sensitive
	\|> add_hashtags
	\|> add_mention_tags
	\|> add_emoji_tags
	\|> add_attributed_to
	\|> add_likes
	\|> prepare_attachments
	\|> set_conversation
	\|> set_reply_to_uri
	\|> strip_internal_fields
	\|> strip_internal_tags
	end

	# @doc
	# """
	# internal -> Mastodon
	# """

	def prepare_outgoing(%{"type" => "Create", "object" => object} = data) do
	object =
	object
	\|> prepare_object

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end

	# Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
	# because of course it does.
	def prepare_outgoing(%{"type" => "Accept"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => "Reject"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => _type} = data) do
	data =
	data
	\|> maybe_fix_object_url
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end

	def maybe_fix_object_url(data) do
	if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
	case fetch_obj_helper(data["object"]) do
	{:ok, relative_object} ->
	if relative_object.data["external_url"] do
	_data =
	data
	\|> Map.put("object", relative_object.data["external_url"])
	else
	data
	end

	e ->
	Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
	data
	end
	else
	data
	end
	end

	def add_hashtags(object) do
	tags =
	(object["tag"] \|\| [])
	\|> Enum.map(fn tag ->
	%{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
	"name" => "##{tag}",
	"type" => "Hashtag"
	}
	end)

	object
	\|> Map.put("tag", tags)
	end

	def add_mention_tags(object) do
	mentions =
	object
	\|> Utils.get_notified_from_object()
	\|> Enum.map(fn user ->
	%{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
	end)

	tags = object["tag"] \|\| []

	object
	\|> Map.put("tag", tags ++ mentions)
	end

	# TODO: we should probably send mtime instead of unix epoch time for updated
	def add_emoji_tags(object) do
	tags = object["tag"] \|\| []
	emoji = object["emoji"] \|\| []

	out =
	emoji
	\|> Enum.map(fn {name, url} ->
	%{
	"icon" => %{"url" => url, "type" => "Image"},
	"name" => ":" <> name <> ":",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z",
	"id" => url
	}
	end)

	object
	\|> Map.put("tag", tags ++ out)
	end

	def set_conversation(object) do
	Map.put(object, "conversation", object["context"])
	end

	def set_sensitive(object) do
	tags = object["tag"] \|\| []
	Map.put(object, "sensitive", "nsfw" in tags)
	end

	def add_attributed_to(object) do
	attributedTo = object["attributedTo"] \|\| object["actor"]

	object
	\|> Map.put("attributedTo", attributedTo)
	end

	def add_likes(%{"id" => id, "like_count" => likes} = object) do
	likes = %{
	"id" => "#{id}/likes",
	"first" => "#{id}/likes?page=1",
	"type" => "OrderedCollection",
	"totalItems" => likes
	}

	object
	\|> Map.put("likes", likes)
	end

	def add_likes(object) do
	object
	end

	def prepare_attachments(object) do
	attachments =
	(object["attachment"] \|\| [])
	\|> Enum.map(fn data ->
	[%{"mediaType" => media_type, "href" => href} \| _] = data["url"]
	%{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
	end)

	object
	\|> Map.put("attachment", attachments)
	end

	defp strip_internal_fields(object) do
	object
	\|> Map.drop([
	"like_count",
	"announcements",
	"announcement_count",
	"emoji",
	"context_id"
	])
	end

	defp strip_internal_tags(%{"tag" => tags} = object) do
	tags =
	tags
	\|> Enum.filter(fn x -> is_map(x) end)

	object
	\|> Map.put("tag", tags)
	end

	defp strip_internal_tags(object), do: object

	defp user_upgrade_task(user) do
	old_follower_address = User.ap_followers(user)

	q =
	from(
	u in User,
	where: ^old_follower_address in u.following,
	update: [
	set: [
	following:
	fragment(
	"array_replace(?,?,?)",
	u.following,
	^old_follower_address,
	^user.follower_address
	)
	]
	]
	)

	Repo.update_all(q, [])

	maybe_retire_websub(user.ap_id)

	# Only do this for recent activties, don't go through the whole db.
	# Only look at the last 1000 activities.
	since = (Repo.aggregate(Activity, :max, :id) \|\| 0) - 1_000

	q =
	from(
	a in Activity,
	where: ^old_follower_address in a.recipients,
	where: a.id > ^since,
	update: [
	set: [
	recipients:
	fragment(
	"array_replace(?,?,?)",
	a.recipients,
	^old_follower_address,
	^user.follower_address
	)
	]
	]
	)

	Repo.update_all(q, [])
	end

	def upgrade_user_from_ap_id(ap_id, async \\ true) do
	with %User{local: false} = user <- User.get_by_ap_id(ap_id),
	{:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
	already_ap = User.ap_enabled?(user)

	{:ok, user} =
	User.upgrade_changeset(user, data)
	\|> Repo.update()

	if !already_ap do
	# This could potentially take a long time, do it in the background
	if async do
	Task.start(fn ->
	user_upgrade_task(user)
	end)
	else
	user_upgrade_task(user)
	end
	end

	{:ok, user}
	else
	e -> e
	end
	end

	def maybe_retire_websub(ap_id) do
	# some sanity checks
	if is_binary(ap_id) && String.length(ap_id) > 8 do
	q =
	from(
	ws in Pleroma.Web.Websub.WebsubClientSubscription,
	where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
	)

	Repo.delete_all(q)
	end
	end

	def maybe_fix_user_url(data) do
	if is_map(data["url"]) do
	Map.put(data, "url", data["url"]["href"])
	else
	data
	end
	end

	def maybe_fix_user_object(data) do
	data
	\|> maybe_fix_user_url
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index d2e457a68..d516818d9 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,560 +1,574 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Utils do
	alias Pleroma.{Repo, Web, Object, Activity, User, Notification}
	alias Pleroma.Web.Router.Helpers
	alias Pleroma.Web.Endpoint
	alias Ecto.{Changeset, UUID}
	import Ecto.Query
	require Logger

	@supported_object_types ["Article", "Note", "Video", "Page"]

	# Some implementations send the actor URI as the actor field, others send the entire actor object,
	# so figure out what the actor's URI is based on what we have.
	def get_ap_id(object) do
	case object do
	%{"id" => id} -> id
	id -> id
	end
	end

	def normalize_params(params) do
	Map.put(params, "actor", get_ap_id(params["actor"]))
	end

	+ def determine_explicit_mentions(%{"tag" => tag} = _object) when is_list(tag) do
	+ tag
	+ \|> Enum.filter(fn x -> is_map(x) end)
	+ \|> Enum.filter(fn x -> x["type"] == "Mention" end)
	+ \|> Enum.map(fn x -> x["href"] end)
	+ end
	+
	+ def determine_explicit_mentions(%{"tag" => tag} = object) when is_map(tag) do
	+ Map.put(object, "tag", [tag])
	+ \|> determine_explicit_mentions()
	+ end
	+
	+ def determine_explicit_mentions(_), do: []
	+
	defp recipient_in_collection(ap_id, coll) when is_binary(coll), do: ap_id == coll
	defp recipient_in_collection(ap_id, coll) when is_list(coll), do: ap_id in coll
	defp recipient_in_collection(_, _), do: false

	def recipient_in_message(ap_id, params) do
	cond do
	recipient_in_collection(ap_id, params["to"]) ->
	true

	recipient_in_collection(ap_id, params["cc"]) ->
	true

	recipient_in_collection(ap_id, params["bto"]) ->
	true

	recipient_in_collection(ap_id, params["bcc"]) ->
	true

	# if the message is unaddressed at all, then assume it is directly addressed
	# to the recipient
	!params["to"] && !params["cc"] && !params["bto"] && !params["bcc"] ->
	true

	true ->
	false
	end
	end

	defp extract_list(target) when is_binary(target), do: [target]
	defp extract_list(lst) when is_list(lst), do: lst
	defp extract_list(_), do: []

	def maybe_splice_recipient(ap_id, params) do
	need_splice =
	!recipient_in_collection(ap_id, params["to"]) &&
	!recipient_in_collection(ap_id, params["cc"])

	cc_list = extract_list(params["cc"])

	if need_splice do
	params
	\|> Map.put("cc", [ap_id \| cc_list])
	else
	params
	end
	end

	def make_json_ld_header do
	%{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"#{Web.base_url()}/schemas/litepub-0.1.jsonld"
	]
	}
	end

	def make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601()
	end

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	Helpers.o_status_url(Endpoint, :object, UUID.generate())
	end

	def generate_id(type) do
	"#{Web.base_url()}/#{type}/#{UUID.generate()}"
	end

	def get_notified_from_object(%{"type" => type} = object) when type in @supported_object_types do
	fake_create_activity = %{
	"to" => object["to"],
	"cc" => object["cc"],
	"type" => "Create",
	"object" => object
	}

	Notification.get_notified_from_activity(%Activity{data: fake_create_activity}, false)
	end

	def get_notified_from_object(object) do
	Notification.get_notified_from_activity(%Activity{data: object}, false)
	end

	def create_context(context) do
	context = context \|\| generate_id("contexts")
	changeset = Object.context_mapping(context)

	case Repo.insert(changeset) do
	{:ok, object} ->
	object

	# This should be solved by an upsert, but it seems ecto
	# has problems accessing the constraint inside the jsonb.
	{:error, _} ->
	Object.get_cached_by_ap_id(context)
	end
	end

	@doc """
	Enqueues an activity for federation if it's local
	"""
	def maybe_federate(%Activity{local: true} = activity) do
	priority =
	case activity.data["type"] do
	"Delete" -> 10
	"Create" -> 1
	_ -> 5
	end

	Pleroma.Web.Federator.enqueue(:publish, activity, priority)
	:ok
	end

	def maybe_federate(_), do: :ok

	@doc """
	Adds an id and a published data if they aren't there,
	also adds it to an included object
	"""
	def lazy_put_activity_defaults(map) do
	%{data: %{"id" => context}, id: context_id} = create_context(map["context"])

	map =
	map
	\|> Map.put_new_lazy("id", &generate_activity_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", context)
	\|> Map.put_new("context_id", context_id)

	if is_map(map["object"]) do
	object = lazy_put_object_defaults(map["object"], map)
	%{map \| "object" => object}
	else
	map
	end
	end

	@doc """
	Adds an id and published date if they aren't there.
	"""
	def lazy_put_object_defaults(map, activity \\ %{}) do
	map
	\|> Map.put_new_lazy("id", &generate_object_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("context_id", activity["context_id"])
	end

	@doc """
	Inserts a full object if it is contained in an activity.
	"""
	def insert_full_object(%{"object" => %{"type" => type} = object_data})
	when is_map(object_data) and type in @supported_object_types do
	with {:ok, _} <- Object.create(object_data) do
	:ok
	end
	end

	def insert_full_object(_), do: :ok

	def update_object_in_activities(%{data: %{"id" => id}} = object) do
	# TODO
	# Update activities that already had this. Could be done in a seperate process.
	# Alternatively, just don't do this and fetch the current object each time. Most
	# could probably be taken from cache.
	relevant_activities = Activity.all_by_object_ap_id(id)

	Enum.map(relevant_activities, fn activity ->
	new_activity_data = activity.data \|> Map.put("object", object.data)
	changeset = Changeset.change(activity, data: new_activity_data)
	Repo.update(changeset)
	end)
	end

	#### Like-related helpers

	@doc """
	Returns an existing like if a user already liked an object
	"""
	def get_existing_like(actor, %{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	where: fragment("(?)->>'actor' = ?", activity.data, ^actor),
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Like'", activity.data)
	)

	Repo.one(query)
	end

	@doc """
	Returns like activities targeting an object
	"""
	def get_object_likes(%{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Like'", activity.data)
	)

	Repo.all(query)
	end

	def make_like_data(%User{ap_id: ap_id} = actor, %{data: %{"id" => id}} = object, activity_id) do
	data = %{
	"type" => "Like",
	"actor" => ap_id,
	"object" => id,
	"to" => [actor.follower_address, object.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def update_element_in_object(property, element, object) do
	with new_data <-
	object.data
	\|> Map.put("#{property}_count", length(element))
	\|> Map.put("#{property}s", element),
	changeset <- Changeset.change(object, data: new_data),
	{:ok, object} <- Repo.update(changeset),
	_ <- update_object_in_activities(object) do
	{:ok, object}
	end
	end

	def update_likes_in_object(likes, object) do
	update_element_in_object("like", likes, object)
	end

	def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
	likes = if is_list(object.data["likes"]), do: object.data["likes"], else: []

	with likes <- [actor \| likes] \|> Enum.uniq() do
	update_likes_in_object(likes, object)
	end
	end

	def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
	likes = if is_list(object.data["likes"]), do: object.data["likes"], else: []

	with likes <- likes \|> List.delete(actor) do
	update_likes_in_object(likes, object)
	end
	end

	#### Follow-related helpers

	@doc """
	Updates a follow activity's state (for locked accounts).
	"""
	def update_follow_state(%Activity{} = activity, state) do
	with new_data <-
	activity.data
	\|> Map.put("state", state),
	changeset <- Changeset.change(activity, data: new_data),
	{:ok, activity} <- Repo.update(changeset) do
	{:ok, activity}
	end
	end

	@doc """
	Makes a follow activity data for the given follower and followed
	"""
	def make_follow_data(
	%User{ap_id: follower_id},
	%User{ap_id: followed_id} = _followed,
	activity_id
	) do
	data = %{
	"type" => "Follow",
	"actor" => follower_id,
	"to" => [followed_id],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => followed_id,
	"state" => "pending"
	}

	data = if activity_id, do: Map.put(data, "id", activity_id), else: data

	data
	end

	def fetch_latest_follow(%User{ap_id: follower_id}, %User{ap_id: followed_id}) do
	query =
	from(
	activity in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Follow'",
	activity.data
	),
	where: activity.actor == ^follower_id,
	where:
	fragment(
	"? @> ?",
	activity.data,
	^%{object: followed_id}
	),
	order_by: [desc: :id],
	limit: 1
	)

	Repo.one(query)
	end

	#### Announce-related helpers

	@doc """
	Retruns an existing announce activity if the notice has already been announced
	"""
	def get_existing_announce(actor, %{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	where: activity.actor == ^actor,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Announce'", activity.data)
	)

	Repo.one(query)
	end

	@doc """
	Make announce activity data for the given actor and object
	"""
	# for relayed messages, we only want to send to subscribers
	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	false
	) do
	data = %{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address],
	"cc" => [],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	true
	) do
	data = %{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address, object.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	@doc """
	Make unannounce activity data for the given actor and object
	"""
	def make_unannounce_data(
	%User{ap_id: ap_id} = user,
	%Activity{data: %{"context" => context}} = activity,
	activity_id
	) do
	data = %{
	"type" => "Undo",
	"actor" => ap_id,
	"object" => activity.data,
	"to" => [user.follower_address, activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => context
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_unlike_data(
	%User{ap_id: ap_id} = user,
	%Activity{data: %{"context" => context}} = activity,
	activity_id
	) do
	data = %{
	"type" => "Undo",
	"actor" => ap_id,
	"object" => activity.data,
	"to" => [user.follower_address, activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => context
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def add_announce_to_object(
	%Activity{
	data: %{"actor" => actor, "cc" => ["https://www.w3.org/ns/activitystreams#Public"]}
	},
	object
	) do
	announcements =
	if is_list(object.data["announcements"]), do: object.data["announcements"], else: []

	with announcements <- [actor \| announcements] \|> Enum.uniq() do
	update_element_in_object("announcement", announcements, object)
	end
	end

	def add_announce_to_object(_, object), do: {:ok, object}

	def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
	announcements =
	if is_list(object.data["announcements"]), do: object.data["announcements"], else: []

	with announcements <- announcements \|> List.delete(actor) do
	update_element_in_object("announcement", announcements, object)
	end
	end

	#### Unfollow-related helpers

	def make_unfollow_data(follower, followed, follow_activity, activity_id) do
	data = %{
	"type" => "Undo",
	"actor" => follower.ap_id,
	"to" => [followed.ap_id],
	"object" => follow_activity.data
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	#### Block-related helpers
	def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
	query =
	from(
	activity in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Block'",
	activity.data
	),
	where: activity.actor == ^blocker_id,
	where:
	fragment(
	"? @> ?",
	activity.data,
	^%{object: blocked_id}
	),
	order_by: [desc: :id],
	limit: 1
	)

	Repo.one(query)
	end

	def make_block_data(blocker, blocked, activity_id) do
	data = %{
	"type" => "Block",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => blocked.ap_id
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_unblock_data(blocker, blocked, block_activity, activity_id) do
	data = %{
	"type" => "Undo",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => block_activity.data
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	#### Create-related helpers

	def make_create_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Create",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end
	end
	diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
	index 504670439..7084da6de 100644
	--- a/lib/pleroma/web/common_api/common_api.ex
	+++ b/lib/pleroma/web/common_api/common_api.ex
	@@ -1,219 +1,219 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI do
	alias Pleroma.{User, Repo, Activity, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Formatter

	import Pleroma.Web.CommonAPI.Utils

	def delete(activity_id, user) do
	with %Activity{data: %{"object" => %{"id" => object_id}}} <- Repo.get(Activity, activity_id),
	%Object{} = object <- Object.normalize(object_id),
	true <- user.info.is_moderator \|\| user.ap_id == object.data["actor"],
	{:ok, _} <- unpin(activity_id, user),
	{:ok, delete} <- ActivityPub.delete(object) do
	{:ok, delete}
	end
	end

	def repeat(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity.data["object"]["id"]),
	nil <- Utils.get_existing_announce(user.ap_id, object) do
	ActivityPub.announce(user, object)
	else
	_ ->
	{:error, "Could not repeat"}
	end
	end

	def unrepeat(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity.data["object"]["id"]) do
	ActivityPub.unannounce(user, object)
	else
	_ ->
	{:error, "Could not unrepeat"}
	end
	end

	def favorite(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity.data["object"]["id"]),
	nil <- Utils.get_existing_like(user.ap_id, object) do
	ActivityPub.like(user, object)
	else
	_ ->
	{:error, "Could not favorite"}
	end
	end

	def unfavorite(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity.data["object"]["id"]) do
	ActivityPub.unlike(user, object)
	else
	_ ->
	{:error, "Could not unfavorite"}
	end
	end

	def get_visibility(%{"visibility" => visibility})
	when visibility in ~w{public unlisted private direct},
	do: visibility

	def get_visibility(%{"in_reply_to_status_id" => status_id}) when not is_nil(status_id) do
	case get_replied_to_activity(status_id) do
	nil ->
	"public"

	inReplyTo ->
	Pleroma.Web.MastodonAPI.StatusView.get_visibility(inReplyTo.data["object"])
	end
	end

	def get_visibility(_), do: "public"

	defp get_content_type(content_type) do
	if Enum.member?(Pleroma.Config.get([:instance, :allowed_post_formats]), content_type) do
	content_type
	else
	"text/plain"
	end
	end

	def post(user, %{"status" => status} = data) do
	visibility = get_visibility(data)
	limit = Pleroma.Config.get([:instance, :limit])

	with status <- String.trim(status),
	attachments <- attachments_from_ids(data["media_ids"]),
	mentions <- Formatter.parse_mentions(status),
	inReplyTo <- get_replied_to_activity(data["in_reply_to_status_id"]),
	{to, cc} <- to_for_user_and_mentions(user, mentions, inReplyTo, visibility),
	tags <- Formatter.parse_tags(status, data),
	content_html <-
	make_content_html(
	status,
	mentions,
	attachments,
	tags,
	get_content_type(data["content_type"]),
	Enum.member?(
	[true, "true"],
	Map.get(
	data,
	"no_attachment_links",
	Pleroma.Config.get([:instance, :no_attachment_links], false)
	)
	)
	),
	context <- make_context(inReplyTo),
	cw <- data["spoiler_text"],
	full_payload <- String.trim(status <> (data["spoiler_text"] \|\| "")),
	length when length in 1..limit <- String.length(full_payload),
	object <-
	make_note_data(
	user.ap_id,
	to,
	context,
	content_html,
	attachments,
	inReplyTo,
	tags,
	cw,
	cc
	),
	object <-
	Map.put(
	object,
	"emoji",
	(Formatter.get_emoji(status) ++ Formatter.get_emoji(data["spoiler_text"]))
	\|> Enum.reduce(%{}, fn {name, file}, acc ->
	Map.put(acc, name, "#{Pleroma.Web.Endpoint.static_url()}#{file}")
	end)
	) do
	res =
	ActivityPub.create(%{
	to: to,
	actor: user,
	context: context,
	object: object,
	- additional: %{"cc" => cc}
	+ additional: %{"cc" => cc, "directMessage" => visibility == "direct"}
	})

	res
	end
	end

	# Updates the emojis for a user based on their profile
	def update(user) do
	user =
	with emoji <- emoji_from_profile(user),
	source_data <- (user.info.source_data \|\| %{}) \|> Map.put("tag", emoji),
	info_cng <- Pleroma.User.Info.set_source_data(user.info, source_data),
	change <- Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_cng),
	{:ok, user} <- User.update_and_set_cache(change) do
	user
	else
	_e ->
	user
	end

	ActivityPub.update(%{
	local: true,
	to: [user.follower_address],
	cc: [],
	actor: user.ap_id,
	object: Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
	})
	end

	def pin(id_or_ap_id, %{ap_id: user_ap_id} = user) do
	with %Activity{
	actor: ^user_ap_id,
	data: %{
	"type" => "Create",
	"object" => %{
	"to" => object_to,
	"type" => "Note"
	}
	}
	} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	true <- Enum.member?(object_to, "https://www.w3.org/ns/activitystreams#Public"),
	%{valid?: true} = info_changeset <-
	Pleroma.User.Info.add_pinnned_activity(user.info, activity),
	changeset <-
	Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_changeset),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	{:ok, activity}
	else
	%{errors: [pinned_activities: {err, _}]} ->
	{:error, err}

	_ ->
	{:error, "Could not pin"}
	end
	end

	def unpin(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	%{valid?: true} = info_changeset <-
	Pleroma.User.Info.remove_pinnned_activity(user.info, activity),
	changeset <-
	Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_changeset),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	{:ok, activity}
	else
	%{errors: [pinned_activities: {err, _}]} ->
	{:error, err}

	_ ->
	{:error, "Could not unpin"}
	end
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index 7f5a52ea3..feabf54c6 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,316 +1,319 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusView do
	use Pleroma.Web, :view

	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView

	# TODO: Add cached version.
	defp get_replied_to_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create", "object" => %{"inReplyTo" => in_reply_to}}} ->
	in_reply_to != "" && in_reply_to

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_activity_by_object_id_query()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	Map.put(acc, activity.data["object"]["id"], activity)
	end)
	end

	defp get_user(ap_id) do
	cond do
	user = User.get_cached_by_ap_id(ap_id) ->
	user

	user = User.get_by_guessed_nickname(ap_id) ->
	user

	true ->
	User.error_user(ap_id)
	end
	end

	def render("index.json", opts) do
	replied_to_activities = get_replied_to_activities(opts.activities)

	opts.activities
	\|> render_many(
	StatusView,
	"status.json",
	Map.put(opts, :replied_to_activities, replied_to_activities)
	)
	\|> Enum.filter(fn x -> not is_nil(x) end)
	end

	def render(
	"status.json",
	%{activity: %{data: %{"type" => "Announce", "object" => object}} = activity} = opts
	) do
	user = get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])

	reblogged = Activity.get_create_activity_by_object_ap_id(object)
	reblogged = render("status.json", Map.put(opts, :activity, reblogged))

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	%{
	id: to_string(activity.id),
	uri: object,
	url: object,
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: reblogged,
	content: reblogged[:content] \|\| "",
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	favourited: false,
	muted: false,
	pinned: pinned?(activity, user),
	sensitive: false,
	spoiler_text: "",
	visibility: "public",
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: []
	}
	end

	def render("status.json", %{activity: %{data: %{"object" => object}} = activity} = opts) do
	user = get_user(activity.data["actor"])

	like_count = object["like_count"] \|\| 0
	announcement_count = object["announcement_count"] \|\| 0

	tags = object["tag"] \|\| []
	sensitive = object["sensitive"] \|\| Enum.member?(tags, "nsfw")

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] \|\| [])
	favorited = opts[:for] && opts[:for].ap_id in (object["likes"] \|\| [])

	attachment_data = object["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object["published"])

	reply_to = get_reply_to(activity, opts)
	reply_to_user = reply_to && get_user(reply_to.data["actor"])

	content =
	object
	\|> render_content()
	\|> HTML.get_cached_scrubbed_html_for_object(
	User.html_filter_policy(opts[:for]),
	activity,
	__MODULE__
	)

	%{
	id: to_string(activity.id),
	uri: object["id"],
	url: object["external_url"] \|\| object["id"],
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: reply_to && to_string(reply_to.id),
	in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
	reblog: nil,
	content: content,
	created_at: created_at,
	reblogs_count: announcement_count,
	replies_count: 0,
	favourites_count: like_count,
	reblogged: present?(repeated),
	favourited: present?(favorited),
	muted: false,
	pinned: pinned?(activity, user),
	sensitive: sensitive,
	spoiler_text: object["summary"] \|\| "",
	visibility: get_visibility(object),
	media_attachments: attachments \|> Enum.take(4),
	mentions: mentions,
	tags: build_tags(tags),
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: build_emojis(activity.data["object"]["emoji"])
	}
	end

	def render("status.json", _) do
	nil
	end

	def render("attachment.json", %{attachment: attachment}) do
	[attachment_url \| _] = attachment["url"]
	media_type = attachment_url["mediaType"] \|\| attachment_url["mimeType"] \|\| "image"
	href = attachment_url["href"] \|> MediaProxy.url()

	type =
	cond do
	String.contains?(media_type, "image") -> "image"
	String.contains?(media_type, "video") -> "video"
	String.contains?(media_type, "audio") -> "audio"
	true -> "unknown"
	end

	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)

	%{
	id: to_string(attachment["id"] \|\| hash_id),
	url: href,
	remote_url: href,
	preview_url: href,
	text_url: href,
	type: type,
	description: attachment["name"]
	}
	end

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	_id = activity.data["object"]["inReplyTo"]
	replied_to_activities[activity.data["object"]["inReplyTo"]]
	end

	def get_reply_to(%{data: %{"object" => object}}, _) do
	if object["inReplyTo"] && object["inReplyTo"] != "" do
	Activity.get_create_activity_by_object_ap_id(object["inReplyTo"])
	else
	nil
	end
	end

	def get_visibility(object) do
	public = "https://www.w3.org/ns/activitystreams#Public"
	to = object["to"] \|\| []
	cc = object["cc"] \|\| []

	cond do
	public in to ->
	"public"

	public in cc ->
	"unlisted"

	# this should use the sql for the object's activity
	Enum.any?(to, &String.contains?(&1, "/followers")) ->
	"private"

	+ length(cc) > 0 ->
	+ "private"
	+
	true ->
	"direct"
	end
	end

	def render_content(%{"type" => "Video"} = object) do
	with name when not is_nil(name) and name != "" <- object["name"] do
	"<p><a href=\"#{object["id"]}\">#{name}</a></p>#{object["content"]}"
	else
	_ -> object["content"] \|\| ""
	end
	end

	def render_content(%{"type" => object_type} = object)
	when object_type in ["Article", "Page"] do
	with summary when not is_nil(summary) and summary != "" <- object["name"],
	url when is_bitstring(url) <- object["url"] do
	"<p><a href=\"#{url}\">#{summary}</a></p>#{object["content"]}"
	else
	_ -> object["content"] \|\| ""
	end
	end

	def render_content(object), do: object["content"] \|\| ""

	@doc """
	Builds a dictionary tags.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
	[{"name": "fediverse", "url": "/tag/fediverse"},
	{"name": "nextcloud", "url": "/tag/nextcloud"}]

	"""
	@spec build_tags(list(any())) :: list(map())
	def build_tags(object_tags) when is_list(object_tags) do
	object_tags = for tag when is_binary(tag) <- object_tags, do: tag

	Enum.reduce(object_tags, [], fn tag, tags ->
	tags ++ [%{name: tag, url: "/tag/#{tag}"}]
	end)
	end

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

	Arguments: `nil` or list tuple of name and url.

	Returns list emojis.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
	[%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]

	"""
	@spec build_emojis(nil \| list(tuple())) :: list(map())
	def build_emojis(nil), do: []

	def build_emojis(emojis) do
	emojis
	\|> Enum.map(fn {name, url} ->
	name = HTML.strip_tags(name)

	url =
	url
	\|> HTML.strip_tags()
	\|> MediaProxy.url()

	%{shortcode: name, url: url, static_url: url, visible_in_picker: false}
	end)
	end

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true

	defp pinned?(%Activity{id: id}, %User{info: %{pinned_activities: pinned_activities}}),
	do: id in pinned_activities
	end
	diff --git a/priv/static/schemas/litepub-0.1.jsonld b/priv/static/schemas/litepub-0.1.jsonld
	index 819d25c38..15645646a 100644
	--- a/priv/static/schemas/litepub-0.1.jsonld
	+++ b/priv/static/schemas/litepub-0.1.jsonld
	@@ -1,23 +1,25 @@
	{
	"@context": [
	"https://www.w3.org/ns/activitystreams",
	"https://w3id.org/security/v1",
	{
	"Emoji": "toot:Emoji",
	"Hashtag": "as:Hashtag",
	"PropertyValue": "schema:PropertyValue",
	"atomUri": "ostatus:atomUri",
	"conversation": {
	"@id": "ostatus:conversation",
	"@type": "@id"
	},
	"manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
	"ostatus": "http://ostatus.org#",
	"schema": "http://schema.org",
	"toot": "http://joinmastodon.org/ns#",
	"totalItems": "as:totalItems",
	"value": "schema:value",
	- "sensitive": "as:sensitive"
	+ "sensitive": "as:sensitive",
	+ "litepub": "http://litepub.social/ns#",
	+ "directMessage": "litepub:directMessage"
	}
	]
	}
	diff --git a/test/web/activity_pub/transmogrifier_test.exs b/test/web/activity_pub/transmogrifier_test.exs
	index 6107ac4f7..c1d542245 100644
	--- a/test/web/activity_pub/transmogrifier_test.exs
	+++ b/test/web/activity_pub/transmogrifier_test.exs
	@@ -1,1073 +1,1131 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Pleroma.DataCase
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.OStatus
	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Repo
	alias Pleroma.Web.Websub.WebsubClientSubscription

	import Pleroma.Factory
	alias Pleroma.Web.CommonAPI

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "handle_incoming" do
	test "it ignores an incoming notice if we already have it" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity == returned_activity
	end

	test "it fetches replied-to activities if we don't have them" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")

	data =
	data
	\|> Map.put("object", object)

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity =
	Activity.get_create_activity_by_object_ap_id(
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	)

	assert returned_activity.data["object"]["inReplyToAtomUri"] ==
	"https://shitposter.club/notice/2827873"

	assert returned_activity.data["object"]["inReplyToStatusId"] == activity.id
	end

	test "it works for incoming notices" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"

	assert data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert data["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert data["actor"] == "http://mastodon.example.org/users/admin"

	object = data["object"]
	assert object["id"] == "http://mastodon.example.org/users/admin/statuses/99512778738411822"

	assert object["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert object["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert object["actor"] == "http://mastodon.example.org/users/admin"
	assert object["attributedTo"] == "http://mastodon.example.org/users/admin"

	assert object["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert object["sensitive"] == true

	user = User.get_by_ap_id(object["actor"])

	assert user.info.note_count == 1
	end

	test "it works for incoming notices with hashtags" do
	data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert Enum.at(data["object"]["tag"], 2) == "moo"
	end

	test "it works for incoming notices with contentMap" do
	data =
	File.read!("test/fixtures/mastodon-post-activity-contentmap.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["object"]["content"] ==
	"<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
	end

	test "it works for incoming notices with to/cc not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["object"]["content"] ==
	"<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
	end

	test "it works for incoming announces with actor being inlined (kroeg)" do
	data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "https://puckipedia.com/"
	end

	test "it works for incoming notices with tag not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-array-less-emoji.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["object"]["emoji"] == %{
	"icon_e_smile" => "https://puckipedia.com/forum/images/smilies/icon_e_smile.png"
	}

	data = File.read!("test/fixtures/kroeg-array-less-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert "test" in data["object"]["tag"]
	end

	test "it works for incoming notices with url not being a string (prismo)" do
	data = File.read!("test/fixtures/prismo-url-map.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["object"]["url"] == "https://prismo.news/posts/83"
	end

	+ test "it cleans up incoming notices which are not really DMs" do
	+ user = insert(:user)
	+ other_user = insert(:user)
	+
	+ to = [user.ap_id, other_user.ap_id]
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-post-activity.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("to", to)
	+ \|> Map.put("cc", [])
	+
	+ object =
	+ data["object"]
	+ \|> Map.put("to", to)
	+ \|> Map.put("cc", [])
	+
	+ data = Map.put(data, "object", object)
	+
	+ {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+
	+ assert data["to"] == []
	+ assert data["cc"] == to
	+
	+ object = data["object"]
	+
	+ assert object["to"] == []
	+ assert object["cc"] == to
	+ end
	+
	test "it works for incoming follow requests" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Follow"
	assert data["id"] == "http://mastodon.example.org/users/admin#follows/2"
	assert User.following?(User.get_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming follow requests from hubzilla" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/hubzilla-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Utils.normalize_params()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "https://hubzilla.example.org/channel/kaniini"
	assert data["type"] == "Follow"
	assert data["id"] == "https://hubzilla.example.org/channel/kaniini#follows/2"
	assert User.following?(User.get_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming likes" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Like"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2"
	assert data["object"] == activity.data["object"]["id"]
	end

	test "it returns an error for incoming unlikes wihout a like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	assert Transmogrifier.handle_incoming(data) == :error
	end

	test "it works for incoming unlikes with an existing like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	like_data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	{:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", like_data)
	\|> Map.put("actor", like_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Undo"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
	assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
	end

	test "it works for incoming announces" do
	data = File.read!("test/fixtures/mastodon-announce.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] ==
	"http://mastodon.example.org/users/admin/statuses/99541947525187367"

	assert Activity.get_create_activity_by_object_ap_id(data["object"])
	end

	test "it works for incoming announces with an existing activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] == activity.data["object"]["id"]

	assert Activity.get_create_activity_by_object_ap_id(data["object"]).id == activity.id
	end

	test "it does not clobber the addressing on announce activities" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])
	\|> Map.put("to", ["http://mastodon.example.org/users/admin/followers"])
	\|> Map.put("cc", [])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["to"] == ["http://mastodon.example.org/users/admin/followers"]
	end

	test "it works for incoming update activities" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", data["actor"])
	\|> Map.put("id", data["actor"])

	update_data =
	update_data
	\|> Map.put("actor", data["actor"])
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.name == "gargle"

	assert user.avatar["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]

	assert user.info.banner["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]

	assert user.bio == "<p>Some bio</p>"
	end

	test "it works for incoming update activities which lock the account" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", data["actor"])
	\|> Map.put("id", data["actor"])
	\|> Map.put("manuallyApprovesFollowers", true)

	update_data =
	update_data
	\|> Map.put("actor", data["actor"])
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.info.locked == true
	end

	test "it works for incoming deletes" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("id", activity.data["object"]["id"])

	data =
	data
	\|> Map.put("object", object)
	\|> Map.put("actor", activity.data["actor"])

	{:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)

	refute Repo.get(Activity, activity.id)
	end

	test "it fails for incoming deletes with spoofed origin" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("id", activity.data["object"]["id"])

	data =
	data
	\|> Map.put("object", object)

	:error = Transmogrifier.handle_incoming(data)

	assert Repo.get(Activity, activity.id)
	end

	test "it works for incoming unannounces with an existing notice" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	announce_data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	{:ok, %Activity{data: announce_data, local: false}} =
	Transmogrifier.handle_incoming(announce_data)

	data =
	File.read!("test/fixtures/mastodon-undo-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", announce_data)
	\|> Map.put("actor", announce_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Announce"
	assert data["object"]["object"] == activity.data["object"]["id"]

	assert data["object"]["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
	end

	test "it works for incomming unfollows with an existing follow" do
	user = insert(:user)

	follow_data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)

	data =
	File.read!("test/fixtures/mastodon-unfollow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", follow_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Follow"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	refute User.following?(User.get_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming blocks" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Block"
	assert data["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_by_ap_id(data["actor"])

	assert User.blocks?(blocker, user)
	end

	test "incoming blocks successfully tear down any follow relationship" do
	blocker = insert(:user)
	blocked = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", blocked.ap_id)
	\|> Map.put("actor", blocker.ap_id)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Block"
	assert data["object"] == blocked.ap_id
	assert data["actor"] == blocker.ap_id

	blocker = User.get_by_ap_id(data["actor"])
	blocked = User.get_by_ap_id(data["object"])

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "it works for incoming unblocks with an existing block" do
	user = insert(:user)

	block_data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)

	data =
	File.read!("test/fixtures/mastodon-unblock-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", block_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Block"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_by_ap_id(data["actor"])

	refute User.blocks?(blocker, user)
	end

	test "it works for incoming accepts which were pre-accepted" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follower} = User.follow(follower, followed)
	assert User.following?(follower, followed) == true

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	object =
	accept_data["object"]
	\|> Map.put("actor", follower.ap_id)
	\|> Map.put("id", follow_activity.data["id"])

	accept_data = Map.put(accept_data, "object", object)

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	refute activity.local

	assert activity.data["object"] == follow_activity.data["id"]

	follower = Repo.get(User, follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which were orphaned" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = Repo.get(User, follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = Repo.get(User, follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it fails for incoming accepts which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

	follower = Repo.get(User, follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it fails for incoming rejects which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	accept_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

	follower = Repo.get(User, follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it works for incoming rejects which are orphaned" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follower} = User.follow(follower, followed)
	{:ok, _follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	reject_data =
	Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(reject_data)
	refute activity.local

	follower = Repo.get(User, follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it works for incoming rejects which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follower} = User.follow(follower, followed)
	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)

	follower = Repo.get(User, follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it rejects activities without a valid ID" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Map.put("id", "")

	:error = Transmogrifier.handle_incoming(data)
	end

	test "it remaps video URLs as attachments if necessary" do
	{:ok, object} =
	ActivityPub.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	attachment = %{
	"type" => "Link",
	"mediaType" => "video/mp4",
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mimeType" => "video/mp4",
	"size" => 5_015_880,
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	],
	"width" => 480
	}

	assert object.data["url"] ==
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"

	assert object.data["attachment"] == [attachment]
	end
	end

	describe "prepare outgoing" do
	test "it turns mentions into tags" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
	object = modified["object"]

	expected_mention = %{
	"href" => other_user.ap_id,
	"name" => "@#{other_user.nickname}",
	"type" => "Mention"
	}

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end

	test "it adds the sensitive property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["sensitive"]
	end

	test "it adds the json-ld context and the conversation property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["@context"] ==
	Pleroma.Web.ActivityPub.Utils.make_json_ld_header()["@context"]

	assert modified["object"]["conversation"] == modified["context"]
	end

	test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it translates ostatus IDs to external URLs" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [referent_activity]} = OStatus.handle_incoming(incoming)

	user = insert(:user)

	{:ok, activity, _} = CommonAPI.favorite(referent_activity.id, user)
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"] == "http://gs.example.org:4040/index.php/notice/29"
	end

	test "it translates ostatus reply_to IDs to external URLs" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [referred_activity]} = OStatus.handle_incoming(incoming)

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "HI!", "in_reply_to_status_id" => referred_activity.id})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["inReplyTo"] == "http://gs.example.org:4040/index.php/notice/29"
	end

	test "it strips internal hashtag data" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu"})

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["tag"] == [expected_tag]
	end

	test "it strips internal fields" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["context_id"])
	end

	test "it strips internal fields of article" do
	activity = insert(:article_activity)

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["context_id"])
	end

	test "it adds like collection to object" do
	activity = insert(:note_activity)
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["likes"]["type"] == "OrderedCollection"
	assert modified["object"]["likes"]["totalItems"] == 0
	end
	+
	+ test "the directMessage flag is present" do
	+ user = insert(:user)
	+ other_user = insert(:user)
	+
	+ {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu :moominmamma:"})
	+
	+ {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
	+
	+ assert modified["directMessage"] == false
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{"status" => "@{other_user.nickname} :moominmamma:"})
	+
	+ {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
	+
	+ assert modified["directMessage"] == false
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ "status" => "@{other_user.nickname} :moominmamma:",
	+ "visibility" => "direct"
	+ })
	+
	+ {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
	+
	+ assert modified["directMessage"] == true
	+ end
	end

	describe "user upgrade" do
	test "it upgrades a user to activitypub" do
	user =
	insert(:user, %{
	nickname: "rye@niu.moe",
	local: false,
	ap_id: "https://niu.moe/users/rye",
	follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	})

	user_two = insert(:user, %{following: [user.follower_address]})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
	{:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
	assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients

	user = Repo.get(User, user.id)
	assert user.info.note_count == 1

	{:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
	assert user.info.ap_enabled
	assert user.info.note_count == 1
	assert user.follower_address == "https://niu.moe/users/rye/followers"

	# Wait for the background task
	:timer.sleep(1000)

	user = Repo.get(User, user.id)
	assert user.info.note_count == 1

	activity = Repo.get(Activity, activity.id)
	assert user.follower_address in activity.recipients

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]
	} = user.avatar

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]
	} = user.info.banner

	refute "..." in activity.recipients

	unrelated_activity = Repo.get(Activity, unrelated_activity.id)
	refute user.follower_address in unrelated_activity.recipients

	user_two = Repo.get(User, user_two.id)
	assert user.follower_address in user_two.following
	refute "..." in user_two.following
	end
	end

	describe "maybe_retire_websub" do
	test "it deletes all websub client subscripitions with the user as topic" do
	subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/rye.atom"}
	{:ok, ws} = Repo.insert(subscription)

	subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/pasty.atom"}
	{:ok, ws2} = Repo.insert(subscription)

	Transmogrifier.maybe_retire_websub("https://niu.moe/users/rye")

	refute Repo.get(WebsubClientSubscription, ws.id)
	assert Repo.get(WebsubClientSubscription, ws2.id)
	end
	end

	describe "actor rewriting" do
	test "it fixes the actor URL property to be a proper URI" do
	data = %{
	"url" => %{"href" => "http://example.com"}
	}

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end

	describe "actor origin containment" do
	test "it rejects objects with a bogus origin" do
	{:error, _} = ActivityPub.fetch_object_from_id("https://info.pleroma.site/activity.json")
	end

	test "it rejects activities which reference objects with bogus origins" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end

	test "it rejects objects when attributedTo is wrong (variant 1)" do
	{:error, _} = ActivityPub.fetch_object_from_id("https://info.pleroma.site/activity2.json")
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity2.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end

	test "it rejects objects when attributedTo is wrong (variant 2)" do
	{:error, _} = ActivityPub.fetch_object_from_id("https://info.pleroma.site/activity3.json")
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity3.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end
	end

	describe "general origin containment" do
	test "contain_origin_from_id() catches obvious spoofing attempts" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:error =
	Transmogrifier.contain_origin_from_id(
	"http://example.org/~alyssa/activities/1234.json",
	data
	)
	end

	test "contain_origin_from_id() allows alternate IDs within the same origin domain" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:ok =
	Transmogrifier.contain_origin_from_id(
	"http://example.com/~alyssa/activities/1234",
	data
	)
	end

	test "contain_origin_from_id() allows matching IDs" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:ok =
	Transmogrifier.contain_origin_from_id(
	"http://example.com/~alyssa/activities/1234.json",
	data
	)
	end

	test "users cannot be collided through fake direction spoofing attempts" do
	insert(:user, %{
	nickname: "rye@niu.moe",
	local: false,
	ap_id: "https://niu.moe/users/rye",
	follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	})

	{:error, _} = User.get_or_fetch_by_ap_id("https://n1u.moe/users/rye")
	end

	test "all objects with fake directions are rejected by the object fetcher" do
	{:error, _} =
	ActivityPub.fetch_and_contain_remote_object_from_id(
	"https://info.pleroma.site/activity4.json"
	)
	end
	end
	end
	diff --git a/test/web/activity_pub/utils_test.exs b/test/web/activity_pub/utils_test.exs
	new file mode 100644
	index 000000000..aeed0564c
	--- /dev/null
	+++ b/test/web/activity_pub/utils_test.exs
	@@ -0,0 +1,57 @@
	+defmodule Pleroma.Web.ActivityPub.UtilsTest do
	+ use Pleroma.DataCase
	+ alias Pleroma.Web.ActivityPub.Utils
	+
	+ describe "determine_explicit_mentions()" do
	+ test "works with an object that has mentions" do
	+ object = %{
	+ "tag" => [
	+ %{
	+ "type" => "Mention",
	+ "href" => "https://example.com/~alyssa",
	+ "name" => "Alyssa P. Hacker"
	+ }
	+ ]
	+ }
	+
	+ assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	+ end
	+
	+ test "works with an object that does not have mentions" do
	+ object = %{
	+ "tag" => [
	+ %{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	+ ]
	+ }
	+
	+ assert Utils.determine_explicit_mentions(object) == []
	+ end
	+
	+ test "works with an object that has mentions and other tags" do
	+ object = %{
	+ "tag" => [
	+ %{
	+ "type" => "Mention",
	+ "href" => "https://example.com/~alyssa",
	+ "name" => "Alyssa P. Hacker"
	+ },
	+ %{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	+ ]
	+ }
	+
	+ assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	+ end
	+
	+ test "works with an object that has no tags" do
	+ object = %{}
	+
	+ assert Utils.determine_explicit_mentions(object) == []
	+ end
	+
	+ test "works with an object that has only IR tags" do
	+ object = %{"tag" => ["2hu"]}
	+
	+ assert Utils.determine_explicit_mentions(object) == []
	+ end
	+ end
	+end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 30, 9:09 PM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1738158
Default Alt Text: (128 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions