No OneTemporary
Actions

Authored By

Unknown

Size

97 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/activity_pub_controller.ex b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	index 7cd13b4b8..080030eb5 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	@@ -1,540 +1,508 @@
	# 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.ActivityPubController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Delivery
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator

	require Logger

	action_fallback(:errors)

	plug(
	Pleroma.Plugs.Cache,
	[query_params: false, tracking_fun: &__MODULE__.track_object_fetch/2]
	when action in [:activity, :object]
	)

	plug(Pleroma.Web.FederatingPlug when action in [:inbox, :relay])
	plug(:set_requester_reachable when action in [:inbox])
	plug(:relay_active? when action in [:relay])

	def relay_active?(conn, _) do
	if Pleroma.Config.get([:instance, :allow_relay]) do
	conn
	else
	conn
	\|> render_error(:not_found, "not found")
	\|> halt()
	end
	end

	def user(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("user.json", %{user: user})
	else
	nil -> {:error, :not_found}
	end
	end

	def object(conn, %{"uuid" => uuid}) do
	with ap_id <- o_status_url(conn, :object, uuid),
	%Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(object)} do
	conn
	\|> assign(:tracking_fun_data, object.id)
	\|> set_cache_ttl_for(object)
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(ObjectView)
	\|> render("object.json", object: object)
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def track_object_fetch(conn, nil), do: conn

	def track_object_fetch(conn, object_id) do
	with %{assigns: %{user: %User{id: user_id}}} <- conn do
	Delivery.create(object_id, user_id)
	end

	conn
	end

	- def object_likes(conn, %{"uuid" => uuid, "page" => page}) do
	- with ap_id <- o_status_url(conn, :object, uuid),
	- %Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	- {_, true} <- {:public?, Visibility.is_public?(object)},
	- likes <- Utils.get_object_likes(object) do
	- {page, _} = Integer.parse(page)
	-
	- conn
	- \|> put_resp_content_type("application/activity+json")
	- \|> put_view(ObjectView)
	- \|> render("likes.json", %{ap_id: ap_id, likes: likes, page: page})
	- else
	- {:public?, false} ->
	- {:error, :not_found}
	- end
	- end
	-
	- def object_likes(conn, %{"uuid" => uuid}) do
	- with ap_id <- o_status_url(conn, :object, uuid),
	- %Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	- {_, true} <- {:public?, Visibility.is_public?(object)},
	- likes <- Utils.get_object_likes(object) do
	- conn
	- \|> put_resp_content_type("application/activity+json")
	- \|> put_view(ObjectView)
	- \|> render("likes.json", %{ap_id: ap_id, likes: likes})
	- else
	- {:public?, false} ->
	- {:error, :not_found}
	- end
	- end
	-
	def activity(conn, %{"uuid" => uuid}) do
	with ap_id <- o_status_url(conn, :activity, uuid),
	%Activity{} = activity <- Activity.normalize(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(activity)} do
	conn
	\|> maybe_set_tracking_data(activity)
	\|> set_cache_ttl_for(activity)
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(ObjectView)
	\|> render("object.json", object: activity)
	else
	{:public?, false} -> {:error, :not_found}
	nil -> {:error, :not_found}
	end
	end

	defp maybe_set_tracking_data(conn, %Activity{data: %{"type" => "Create"}} = activity) do
	object_id = Object.normalize(activity).id
	assign(conn, :tracking_fun_data, object_id)
	end

	defp maybe_set_tracking_data(conn, _activity), do: conn

	defp set_cache_ttl_for(conn, %Activity{object: object}) do
	set_cache_ttl_for(conn, object)
	end

	defp set_cache_ttl_for(conn, entity) do
	ttl =
	case entity do
	%Object{data: %{"type" => "Question"}} ->
	Pleroma.Config.get([:web_cache_ttl, :activity_pub_question])

	%Object{} ->
	Pleroma.Config.get([:web_cache_ttl, :activity_pub])

	_ ->
	nil
	end

	assign(conn, :cache_ttl, ttl)
	end

	# GET /relay/following
	def following(%{assigns: %{relay: true}} = conn, _params) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("following.json", %{user: Relay.get_actor()})
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user),
	{:show_follows, true} <-
	{:show_follows, (for_user && for_user == user) \|\| !user.info.hide_follows} do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("following.json", %{user: user, page: page, for: for_user})
	else
	{:show_follows, _} ->
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> send_resp(403, "")
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("following.json", %{user: user, for: for_user})
	end
	end

	# GET /relay/followers
	def followers(%{assigns: %{relay: true}} = conn, _params) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("followers.json", %{user: Relay.get_actor()})
	end

	def followers(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user),
	{:show_followers, true} <-
	{:show_followers, (for_user && for_user == user) \|\| !user.info.hide_followers} do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("followers.json", %{user: user, page: page, for: for_user})
	else
	{:show_followers, _} ->
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> send_resp(403, "")
	end
	end

	def followers(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("followers.json", %{user: user, for: for_user})
	end
	end

	def outbox(conn, %{"nickname" => nickname, "page" => page?} = params)
	when page? in [true, "true"] do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- User.ensure_keys_present(user) do
	activities =
	if params["max_id"] do
	ActivityPub.fetch_user_activities(user, nil, %{
	"max_id" => params["max_id"],
	# This is a hack because postgres generates inefficient queries when filtering by
	# 'Answer', poll votes will be hidden by the visibility filter in this case anyway
	"include_poll_votes" => true,
	"limit" => 10
	})
	else
	ActivityPub.fetch_user_activities(user, nil, %{
	"limit" => 10,
	"include_poll_votes" => true
	})
	end

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection_page.json", %{
	activities: activities,
	iri: "#{user.ap_id}/outbox"
	})
	end
	end

	def outbox(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection.json", %{iri: "#{user.ap_id}/outbox"})
	end
	end

	def inbox(%{assigns: %{valid_signature: true}} = conn, %{"nickname" => nickname} = params) do
	with %User{} = recipient <- User.get_cached_by_nickname(nickname),
	{:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(params["actor"]),
	true <- Utils.recipient_in_message(recipient, actor, params),
	params <- Utils.maybe_splice_recipient(recipient.ap_id, params) do
	Federator.incoming_ap_doc(params)
	json(conn, "ok")
	end
	end

	def inbox(%{assigns: %{valid_signature: true}} = conn, params) do
	Federator.incoming_ap_doc(params)
	json(conn, "ok")
	end

	# only accept relayed Creates
	def inbox(conn, %{"type" => "Create"} = params) do
	Logger.info(
	"Signature missing or not from author, relayed Create message, fetching object from source"
	)

	Fetcher.fetch_object_from_id(params["object"]["id"])

	json(conn, "ok")
	end

	def inbox(conn, params) do
	headers = Enum.into(conn.req_headers, %{})

	if String.contains?(headers["signature"], params["actor"]) do
	Logger.info(
	"Signature validation error for: #{params["actor"]}, make sure you are forwarding the HTTP Host header!"
	)

	Logger.info(inspect(conn.req_headers))
	end

	json(conn, dgettext("errors", "error"))
	end

	defp represent_service_actor(%User{} = user, conn) do
	with {:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("user.json", %{user: user})
	else
	nil -> {:error, :not_found}
	end
	end

	defp represent_service_actor(nil, _), do: {:error, :not_found}

	def relay(conn, _params) do
	Relay.get_actor()
	\|> represent_service_actor(conn)
	end

	def internal_fetch(conn, _params) do
	InternalFetchActor.get_actor()
	\|> represent_service_actor(conn)
	end

	@doc "Returns the authenticated user's ActivityPub User object or a 404 Not Found if non-authenticated"
	def whoami(%{assigns: %{user: %User{} = user}} = conn, _params) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("user.json", %{user: user})
	end

	def whoami(_conn, _params), do: {:error, :not_found}

	def read_inbox(
	%{assigns: %{user: %{nickname: nickname} = user}} = conn,
	%{"nickname" => nickname, "page" => page?} = params
	)
	when page? in [true, "true"] do
	activities =
	if params["max_id"] do
	ActivityPub.fetch_activities([user.ap_id \| user.following], %{
	"max_id" => params["max_id"],
	"limit" => 10
	})
	else
	ActivityPub.fetch_activities([user.ap_id \| user.following], %{"limit" => 10})
	end

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection_page.json", %{
	activities: activities,
	iri: "#{user.ap_id}/inbox"
	})
	end

	def read_inbox(%{assigns: %{user: %{nickname: nickname} = user}} = conn, %{
	"nickname" => nickname
	}) do
	with {:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection.json", %{iri: "#{user.ap_id}/inbox"})
	end
	end

	def read_inbox(%{assigns: %{user: nil}} = conn, %{"nickname" => nickname}) do
	err = dgettext("errors", "can't read inbox of %{nickname}", nickname: nickname)

	conn
	\|> put_status(:forbidden)
	\|> json(err)
	end

	def read_inbox(%{assigns: %{user: %{nickname: as_nickname}}} = conn, %{
	"nickname" => nickname
	}) do
	err =
	dgettext("errors", "can't read inbox of %{nickname} as %{as_nickname}",
	nickname: nickname,
	as_nickname: as_nickname
	)

	conn
	\|> put_status(:forbidden)
	\|> json(err)
	end

	def handle_user_activity(user, %{"type" => "Create"} = params) do
	object =
	params["object"]
	\|> Map.merge(Map.take(params, ["to", "cc"]))
	\|> Map.put("attributedTo", user.ap_id())
	\|> Transmogrifier.fix_object()

	ActivityPub.create(%{
	to: params["to"],
	actor: user,
	context: object["context"],
	object: object,
	additional: Map.take(params, ["cc"])
	})
	end

	def handle_user_activity(user, %{"type" => "Delete"} = params) do
	with %Object{} = object <- Object.normalize(params["object"]),
	true <- user.info.is_moderator \|\| user.ap_id == object.data["actor"],
	{:ok, delete} <- ActivityPub.delete(object) do
	{:ok, delete}
	else
	_ -> {:error, dgettext("errors", "Can't delete object")}
	end
	end

	def handle_user_activity(user, %{"type" => "Like"} = params) do
	with %Object{} = object <- Object.normalize(params["object"]),
	{:ok, activity, _object} <- ActivityPub.like(user, object) do
	{:ok, activity}
	else
	_ -> {:error, dgettext("errors", "Can't like object")}
	end
	end

	def handle_user_activity(_, _) do
	{:error, dgettext("errors", "Unhandled activity type")}
	end

	def update_outbox(
	%{assigns: %{user: %User{nickname: nickname} = user}} = conn,
	%{"nickname" => nickname} = params
	) do
	actor = user.ap_id()

	params =
	params
	\|> Map.drop(["id"])
	\|> Map.put("actor", actor)
	\|> Transmogrifier.fix_addressing()

	with {:ok, %Activity{} = activity} <- handle_user_activity(user, params) do
	conn
	\|> put_status(:created)
	\|> put_resp_header("location", activity.data["id"])
	\|> json(activity.data)
	else
	{:error, message} ->
	conn
	\|> put_status(:bad_request)
	\|> json(message)
	end
	end

	def update_outbox(%{assigns: %{user: user}} = conn, %{"nickname" => nickname} = _) do
	err =
	dgettext("errors", "can't update outbox of %{nickname} as %{as_nickname}",
	nickname: nickname,
	as_nickname: user.nickname
	)

	conn
	\|> put_status(:forbidden)
	\|> json(err)
	end

	def errors(conn, {:error, :not_found}) do
	conn
	\|> put_status(:not_found)
	\|> json(dgettext("errors", "Not found"))
	end

	def errors(conn, _e) do
	conn
	\|> put_status(:internal_server_error)
	\|> json(dgettext("errors", "error"))
	end

	defp set_requester_reachable(%Plug.Conn{} = conn, _) do
	with actor <- conn.params["actor"],
	true <- is_binary(actor) do
	Pleroma.Instances.set_reachable(actor)
	end

	conn
	end

	defp ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user) do
	{:ok, new_user} = User.ensure_keys_present(user)

	for_user =
	if new_user != user and match?(%User{}, for_user) do
	User.get_cached_by_nickname(for_user.nickname)
	else
	for_user
	end

	{new_user, for_user}
	end

	# TODO: Add support for "object" field
	@doc """
	Endpoint based on <https://www.w3.org/wiki/SocialCG/ActivityPub/MediaUpload>

	Parameters:
	- (required) `file`: data of the media
	- (optionnal) `description`: description of the media, intended for accessibility

	Response:
	- HTTP Code: 201 Created
	- HTTP Body: ActivityPub object to be inserted into another's `attachment` field
	"""
	def upload_media(%{assigns: %{user: user}} = conn, %{"file" => file} = data) do
	with {:ok, object} <-
	ActivityPub.upload(
	file,
	actor: User.ap_id(user),
	description: Map.get(data, "description")
	) do
	Logger.debug(inspect(object))

	conn
	\|> put_status(:created)
	\|> json(object.data)
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index ac5550671..272011a9f 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,754 +1,744 @@
	# 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 Ecto.Changeset
	alias Ecto.UUID
	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers

	import Ecto.Query

	require Logger
	require Pleroma.Constants

	@supported_object_types ["Article", "Note", "Video", "Page", "Question", "Answer", "Audio"]
	@supported_report_states ~w(open closed resolved)
	@valid_visibilities ~w(public unlisted private direct)

	# 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(%{"id" => id} = _), do: id
	def get_ap_id(id), do: id

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

	@spec determine_explicit_mentions(map()) :: map()
	def determine_explicit_mentions(%{"tag" => tag} = _) when is_list(tag) do
	Enum.flat_map(tag, fn
	%{"type" => "Mention", "href" => href} -> [href]
	_ -> []
	end)
	end

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

	def determine_explicit_mentions(_), do: []

	@spec recipient_in_collection(any(), any()) :: boolean()
	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

	@spec recipient_in_message(User.t(), User.t(), map()) :: boolean()
	def recipient_in_message(%User{ap_id: ap_id} = recipient, %User{} = actor, params) do
	addresses = [params["to"], params["cc"], params["bto"], params["bcc"]]

	cond do
	Enum.any?(addresses, &recipient_in_collection(ap_id, &1)) -> true
	# if the message is unaddressed at all, then assume it is directly addressed
	# to the recipient
	Enum.all?(addresses, &is_nil(&1)) -> true
	# if the message is sent from somebody the user is following, then assume it
	# is addressed to the recipient
	User.following?(recipient, actor) -> 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"])

	if need_splice? do
	cc_list = extract_list(params["cc"])
	Map.put(params, "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",
	%{
	"@language" => "und"
	}
	]
	}
	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
	}

	get_notified_from_object(fake_create_activity)
	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")

	# Ecto has problems accessing the constraint inside the jsonb,
	# so we explicitly check for the existed object before insert
	object = Object.get_cached_by_ap_id(context)

	with true <- is_nil(object),
	changeset <- Object.context_mapping(context),
	{:ok, inserted_object} <- Repo.insert(changeset) do
	inserted_object
	else
	_ ->
	object
	end
	end

	@doc """
	Enqueues an activity for federation if it's local
	"""
	@spec maybe_federate(any()) :: :ok
	def maybe_federate(%Activity{local: true} = activity) do
	if Pleroma.Config.get!([:instance, :federating]) do
	Pleroma.Web.Federator.publish(activity)
	end

	: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
	"""
	@spec lazy_put_activity_defaults(map(), boolean) :: map()
	def lazy_put_activity_defaults(map, fake? \\ false)

	def lazy_put_activity_defaults(map, true) do
	map
	\|> Map.put_new("id", "pleroma:fakeid")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", "pleroma:fakecontext")
	\|> Map.put_new("context_id", -1)
	\|> lazy_put_object_defaults(true)
	end

	def lazy_put_activity_defaults(map, _fake?) do
	%{data: %{"id" => context}, id: context_id} = create_context(map["context"])

	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)
	\|> lazy_put_object_defaults(false)
	end

	# Adds an id and published date if they aren't there.
	#
	@spec lazy_put_object_defaults(map(), boolean()) :: map()
	defp lazy_put_object_defaults(%{"object" => map} = activity, true)
	when is_map(map) do
	object =
	map
	\|> Map.put_new("id", "pleroma:fake_object_id")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("context_id", activity["context_id"])
	\|> Map.put_new("fake", true)

	%{activity \| "object" => object}
	end

	defp lazy_put_object_defaults(%{"object" => map} = activity, _)
	when is_map(map) do
	object =
	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"])

	%{activity \| "object" => object}
	end

	defp lazy_put_object_defaults(activity, _), do: activity

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

	{:ok, map, object}
	end
	end

	def insert_full_object(map), do: {:ok, map, nil}

	#### Like-related helpers

	@doc """
	Returns an existing like if a user already liked an object
	"""
	@spec get_existing_like(String.t(), map()) :: Activity.t() \| nil
	def get_existing_like(actor, %{data: %{"id" => id}}) do
	actor
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_object_id(id)
	\|> Activity.Queries.by_type("Like")
	\|> limit(1)
	\|> Repo.one()
	end

	- @doc """
	- Returns like activities targeting an object
	- """
	- def get_object_likes(%{data: %{"id" => id}}) do
	- id
	- \|> Activity.Queries.by_object_id()
	- \|> Activity.Queries.by_type("Like")
	- \|> Repo.all()
	- end
	-
	@spec make_like_data(User.t(), map(), String.t()) :: map()
	def make_like_data(
	%User{ap_id: ap_id} = actor,
	%{data: %{"actor" => object_actor_id, "id" => id}} = object,
	activity_id
	) do
	object_actor = User.get_cached_by_ap_id(object_actor_id)

	to =
	if Visibility.is_public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	%{
	"type" => "Like",
	"actor" => ap_id,
	"object" => id,
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}
	\|> maybe_put("id", activity_id)
	end

	@spec update_element_in_object(String.t(), list(any), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def update_element_in_object(property, element, object) do
	data =
	Map.merge(
	object.data,
	%{"#{property}_count" => length(element), "#{property}s" => element}
	)

	object
	\|> Changeset.change(data: data)
	\|> Object.update_and_set_cache()
	end

	@spec add_like_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
	[actor \| fetch_likes(object)]
	\|> Enum.uniq()
	\|> update_likes_in_object(object)
	end

	@spec remove_like_from_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
	object
	\|> fetch_likes()
	\|> List.delete(actor)
	\|> update_likes_in_object(object)
	end

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

	defp fetch_likes(object) do
	if is_list(object.data["likes"]) do
	object.data["likes"]
	else
	[]
	end
	end

	#### Follow-related helpers

	@doc """
	Updates a follow activity's state (for locked accounts).
	"""
	@spec update_follow_state_for_all(Activity.t(), String.t()) :: {:ok, Activity} \| {:error, any()}
	def update_follow_state_for_all(
	%Activity{data: %{"actor" => actor, "object" => object}} = activity,
	state
	) do
	"Follow"
	\|> Activity.Queries.by_type()
	\|> Activity.Queries.by_actor(actor)
	\|> Activity.Queries.by_object_id(object)
	\|> where(fragment("data->>'state' = 'pending'"))
	\|> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
	\|> Repo.update_all([])

	User.set_follow_state_cache(actor, object, state)

	activity = Activity.get_by_id(activity.id)

	{:ok, activity}
	end

	def update_follow_state(
	%Activity{data: %{"actor" => actor, "object" => object}} = activity,
	state
	) do
	new_data = Map.put(activity.data, "state", state)
	changeset = Changeset.change(activity, data: new_data)

	with {:ok, activity} <- Repo.update(changeset) do
	User.set_follow_state_cache(actor, object, state)
	{: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
	%{
	"type" => "Follow",
	"actor" => follower_id,
	"to" => [followed_id],
	"cc" => [Pleroma.Constants.as_public()],
	"object" => followed_id,
	"state" => "pending"
	}
	\|> maybe_put("id", activity_id)
	end

	def fetch_latest_follow(%User{ap_id: follower_id}, %User{ap_id: followed_id}) do
	"Follow"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^follower_id)
	# this is to use the index
	\|> Activity.Queries.by_object_id(followed_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	#### Announce-related helpers

	@doc """
	Retruns an existing announce activity if the notice has already been announced
	"""
	@spec get_existing_announce(String.t(), map()) :: Activity.t() \| nil
	def get_existing_announce(actor, %{data: %{"id" => ap_id}}) do
	"Announce"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^actor)
	# this is to use the index
	\|> Activity.Queries.by_object_id(ap_id)
	\|> Repo.one()
	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
	%{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address],
	"cc" => [],
	"context" => object.data["context"]
	}
	\|> maybe_put("id", activity_id)
	end

	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	true
	) do
	%{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address, object.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => object.data["context"]
	}
	\|> maybe_put("id", activity_id)
	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, "object" => object}} = activity,
	activity_id
	) do
	object = Object.normalize(object)

	%{
	"type" => "Undo",
	"actor" => ap_id,
	"object" => activity.data,
	"to" => [user.follower_address, object.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => context
	}
	\|> maybe_put("id", activity_id)
	end

	def make_unlike_data(
	%User{ap_id: ap_id} = user,
	%Activity{data: %{"context" => context, "object" => object}} = activity,
	activity_id
	) do
	object = Object.normalize(object)

	%{
	"type" => "Undo",
	"actor" => ap_id,
	"object" => activity.data,
	"to" => [user.follower_address, object.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => context
	}
	\|> maybe_put("id", activity_id)
	end

	@spec add_announce_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def add_announce_to_object(
	%Activity{data: %{"actor" => actor}},
	object
	) do
	announcements = take_announcements(object)

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

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

	@spec remove_announce_from_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
	with announcements <- List.delete(take_announcements(object), actor) do
	update_element_in_object("announcement", announcements, object)
	end
	end

	defp take_announcements(%{data: %{"announcements" => announcements}} = _)
	when is_list(announcements),
	do: announcements

	defp take_announcements(_), do: []

	#### Unfollow-related helpers

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

	#### Block-related helpers
	@spec fetch_latest_block(User.t(), User.t()) :: Activity.t() \| nil
	def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
	"Block"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^blocker_id)
	# this is to use the index
	\|> Activity.Queries.by_object_id(blocked_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

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

	def make_unblock_data(blocker, blocked, block_activity, activity_id) do
	%{
	"type" => "Undo",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => block_activity.data
	}
	\|> maybe_put("id", activity_id)
	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

	#### Listen-related helpers
	def make_listen_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Listen",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end

	#### Flag-related helpers
	@spec make_flag_data(map(), map()) :: map()
	def make_flag_data(%{actor: actor, context: context, content: content} = params, additional) do
	%{
	"type" => "Flag",
	"actor" => actor.ap_id,
	"content" => content,
	"object" => build_flag_object(params),
	"context" => context,
	"state" => "open"
	}
	\|> Map.merge(additional)
	end

	def make_flag_data(_, _), do: %{}

	defp build_flag_object(%{account: account, statuses: statuses} = _) do
	[account.ap_id] ++
	Enum.map(statuses \|\| [], fn
	%Activity{} = act -> act.data["id"]
	act when is_map(act) -> act["id"]
	act when is_binary(act) -> act
	end)
	end

	defp build_flag_object(_), do: []

	@doc """
	Fetches the OrderedCollection/OrderedCollectionPage from `from`, limiting the amount of pages fetched after
	the first one to `pages_left` pages.
	If the amount of pages is higher than the collection has, it returns whatever was there.
	"""
	def fetch_ordered_collection(from, pages_left, acc \\ []) do
	with {:ok, response} <- Tesla.get(from),
	{:ok, collection} <- Jason.decode(response.body) do
	case collection["type"] do
	"OrderedCollection" ->
	# If we've encountered the OrderedCollection and not the page,
	# just call the same function on the page address
	fetch_ordered_collection(collection["first"], pages_left)

	"OrderedCollectionPage" ->
	if pages_left > 0 do
	# There are still more pages
	if Map.has_key?(collection, "next") do
	# There are still more pages, go deeper saving what we have into the accumulator
	fetch_ordered_collection(
	collection["next"],
	pages_left - 1,
	acc ++ collection["orderedItems"]
	)
	else
	# No more pages left, just return whatever we already have
	acc ++ collection["orderedItems"]
	end
	else
	# Got the amount of pages needed, add them all to the accumulator
	acc ++ collection["orderedItems"]
	end

	_ ->
	{:error, "Not an OrderedCollection or OrderedCollectionPage"}
	end
	end
	end

	#### Report-related helpers

	def update_report_state(%Activity{} = activity, state) when state in @supported_report_states do
	new_data = Map.put(activity.data, "state", state)

	activity
	\|> Changeset.change(data: new_data)
	\|> Repo.update()
	end

	def update_report_state(_, _), do: {:error, "Unsupported state"}

	def update_activity_visibility(activity, visibility) when visibility in @valid_visibilities do
	[to, cc, recipients] =
	activity
	\|> get_updated_targets(visibility)
	\|> Enum.map(&Enum.uniq/1)

	object_data =
	activity.object.data
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	{:ok, object} =
	activity.object
	\|> Object.change(%{data: object_data})
	\|> Object.update_and_set_cache()

	activity_data =
	activity.data
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	activity
	\|> Map.put(:object, object)
	\|> Activity.change(%{data: activity_data, recipients: recipients})
	\|> Repo.update()
	end

	def update_activity_visibility(_, _), do: {:error, "Unsupported visibility"}

	defp get_updated_targets(
	%Activity{data: %{"to" => to} = data, recipients: recipients},
	visibility
	) do
	cc = Map.get(data, "cc", [])
	follower_address = User.get_cached_by_ap_id(data["actor"]).follower_address
	public = Pleroma.Constants.as_public()

	case visibility do
	"public" ->
	to = [public \| List.delete(to, follower_address)]
	cc = [follower_address \| List.delete(cc, public)]
	recipients = [public \| recipients]
	[to, cc, recipients]

	"private" ->
	to = [follower_address \| List.delete(to, public)]
	cc = List.delete(cc, public)
	recipients = List.delete(recipients, public)
	[to, cc, recipients]

	"unlisted" ->
	to = [follower_address \| List.delete(to, public)]
	cc = [public \| List.delete(cc, follower_address)]
	recipients = recipients ++ [follower_address, public]
	[to, cc, recipients]

	_ ->
	[to, cc, recipients]
	end
	end

	def get_existing_votes(actor, %{data: %{"id" => id}}) do
	actor
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Create")
	\|> Activity.with_preloaded_object()
	\|> where([a, object: o], fragment("(?)->>'inReplyTo' = ?", o.data, ^to_string(id)))
	\|> where([a, object: o], fragment("(?)->>'type' = 'Answer'", o.data))
	\|> Repo.all()
	end

	defp maybe_put(map, _key, nil), do: map
	defp maybe_put(map, key, value), do: Map.put(map, key, value)
	end
	diff --git a/lib/pleroma/web/activity_pub/views/object_view.ex b/lib/pleroma/web/activity_pub/views/object_view.ex
	index 88c55acdd..d8a3ec288 100644
	--- a/lib/pleroma/web/activity_pub/views/object_view.ex
	+++ b/lib/pleroma/web/activity_pub/views/object_view.ex
	@@ -1,76 +1,40 @@
	# 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.ObjectView do
	use Pleroma.Web, :view
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Transmogrifier

	def render("object.json", %{object: %Object{} = object}) do
	base = Pleroma.Web.ActivityPub.Utils.make_json_ld_header()

	additional = Transmogrifier.prepare_object(object.data)
	Map.merge(base, additional)
	end

	def render("object.json", %{object: %Activity{data: %{"type" => activity_type}} = activity})
	when activity_type in ["Create", "Listen"] do
	base = Pleroma.Web.ActivityPub.Utils.make_json_ld_header()
	object = Object.normalize(activity)

	additional =
	Transmogrifier.prepare_object(activity.data)
	\|> Map.put("object", Transmogrifier.prepare_object(object.data))

	Map.merge(base, additional)
	end

	def render("object.json", %{object: %Activity{} = activity}) do
	base = Pleroma.Web.ActivityPub.Utils.make_json_ld_header()
	object = Object.normalize(activity)

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

	Map.merge(base, additional)
	end
	-
	- def render("likes.json", %{ap_id: ap_id, likes: likes, page: page}) do
	- collection(likes, "#{ap_id}/likes", page)
	- \|> Map.merge(Pleroma.Web.ActivityPub.Utils.make_json_ld_header())
	- end
	-
	- def render("likes.json", %{ap_id: ap_id, likes: likes}) do
	- %{
	- "id" => "#{ap_id}/likes",
	- "type" => "OrderedCollection",
	- "totalItems" => length(likes),
	- "first" => collection(likes, "#{ap_id}/likes", 1)
	- }
	- \|> Map.merge(Pleroma.Web.ActivityPub.Utils.make_json_ld_header())
	- end
	-
	- def collection(collection, iri, page) do
	- offset = (page - 1) * 10
	- items = Enum.slice(collection, offset, 10)
	- items = Enum.map(items, fn object -> Transmogrifier.prepare_object(object.data) end)
	- total = length(collection)
	-
	- map = %{
	- "id" => "#{iri}?page=#{page}",
	- "type" => "OrderedCollectionPage",
	- "partOf" => iri,
	- "totalItems" => total,
	- "orderedItems" => items
	- }
	-
	- if offset + length(items) < total do
	- Map.put(map, "next", "#{iri}?page=#{page + 1}")
	- else
	- map
	- end
	- end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index f91af8137..405ae724e 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,706 +1,705 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router

	pipeline :browser do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	end

	pipeline :oauth do
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	end

	pipeline :api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :authenticated_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :admin_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.AdminSecretAuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.UserIsAdminPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :mastodon_html do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :pleroma_html do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :oauth_read_or_public do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{
	scopes: ["read"],
	fallback: :proceed_unauthenticated
	})

	plug(Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug)
	end

	pipeline :oauth_read do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["read"]})
	end

	pipeline :oauth_write do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["write"]})
	end

	pipeline :oauth_follow do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["follow"]})
	end

	pipeline :oauth_push do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["push"]})
	end

	pipeline :well_known do
	plug(:accepts, ["json", "jrd+json", "xml", "xrd+xml"])
	end

	pipeline :config do
	plug(:accepts, ["json", "xml"])
	end

	pipeline :pleroma_api do
	plug(:accepts, ["html", "json"])
	end

	pipeline :mailbox_preview do
	plug(:accepts, ["html"])

	plug(:put_secure_browser_headers, %{
	"content-security-policy" =>
	"default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline' 'unsafe-eval'"
	})
	end

	pipeline :http_signature do
	plug(Pleroma.Web.Plugs.HTTPSignaturePlug)
	plug(Pleroma.Web.Plugs.MappedSignatureToIdentityPlug)
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_api)

	get("/password_reset/:token", PasswordController, :reset, as: :reset_password)
	post("/password_reset", PasswordController, :do_reset, as: :reset_password)
	get("/emoji", UtilController, :emoji)
	get("/captcha", UtilController, :captcha)
	get("/healthcheck", UtilController, :healthcheck)
	end

	scope "/api/pleroma", Pleroma.Web do
	pipe_through(:pleroma_api)
	post("/uploader_callback/:upload_path", UploaderController, :callback)
	end

	scope "/api/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through([:admin_api, :oauth_write])

	post("/users/follow", AdminAPIController, :user_follow)
	post("/users/unfollow", AdminAPIController, :user_unfollow)

	delete("/users", AdminAPIController, :user_delete)
	post("/users", AdminAPIController, :users_create)
	patch("/users/:nickname/toggle_activation", AdminAPIController, :user_toggle_activation)
	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)

	get("/users/:nickname/permission_group", AdminAPIController, :right_get)
	get("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_get)
	post("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_add)

	delete(
	"/users/:nickname/permission_group/:permission_group",
	AdminAPIController,
	:right_delete
	)

	put("/users/:nickname/activation_status", AdminAPIController, :set_activation_status)

	post("/relay", AdminAPIController, :relay_follow)
	delete("/relay", AdminAPIController, :relay_unfollow)

	post("/users/invite_token", AdminAPIController, :create_invite_token)
	get("/users/invites", AdminAPIController, :invites)
	post("/users/revoke_invite", AdminAPIController, :revoke_invite)
	post("/users/email_invite", AdminAPIController, :email_invite)

	get("/users/:nickname/password_reset", AdminAPIController, :get_password_reset)
	patch("/users/:nickname/force_password_reset", AdminAPIController, :force_password_reset)

	get("/users", AdminAPIController, :list_users)
	get("/users/:nickname", AdminAPIController, :user_show)
	get("/users/:nickname/statuses", AdminAPIController, :list_user_statuses)

	get("/reports", AdminAPIController, :list_reports)
	get("/reports/:id", AdminAPIController, :report_show)
	put("/reports/:id", AdminAPIController, :report_update_state)
	post("/reports/:id/respond", AdminAPIController, :report_respond)

	put("/statuses/:id", AdminAPIController, :status_update)
	delete("/statuses/:id", AdminAPIController, :status_delete)

	get("/config", AdminAPIController, :config_show)
	post("/config", AdminAPIController, :config_update)
	get("/config/migrate_to_db", AdminAPIController, :migrate_to_db)
	get("/config/migrate_from_db", AdminAPIController, :migrate_from_db)

	get("/moderation_log", AdminAPIController, :list_log)

	post("/reload_emoji", AdminAPIController, :reload_emoji)
	end

	scope "/api/pleroma/emoji", Pleroma.Web.PleromaAPI do
	scope "/packs" do
	# Modifying packs
	pipe_through([:admin_api, :oauth_write])

	post("/import_from_fs", EmojiAPIController, :import_from_fs)

	post("/:pack_name/update_file", EmojiAPIController, :update_file)
	post("/:pack_name/update_metadata", EmojiAPIController, :update_metadata)
	put("/:name", EmojiAPIController, :create)
	delete("/:name", EmojiAPIController, :delete)
	post("/download_from", EmojiAPIController, :download_from)
	post("/list_from", EmojiAPIController, :list_from)
	end

	scope "/packs" do
	# Pack info / downloading
	get("/", EmojiAPIController, :list_packs)
	get("/:name/download_shared/", EmojiAPIController, :download_shared)
	end
	end

	scope "/", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_html)

	post("/main/ostatus", UtilController, :remote_subscribe)
	get("/ostatus_subscribe", UtilController, :remote_follow)

	scope [] do
	pipe_through(:oauth_follow)
	post("/ostatus_subscribe", UtilController, :do_remote_follow)
	end
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:authenticated_api)

	scope [] do
	pipe_through(:oauth_write)

	post("/change_email", UtilController, :change_email)
	post("/change_password", UtilController, :change_password)
	post("/delete_account", UtilController, :delete_account)
	put("/notification_settings", UtilController, :update_notificaton_settings)
	post("/disable_account", UtilController, :disable_account)
	end

	scope [] do
	pipe_through(:oauth_follow)

	post("/blocks_import", UtilController, :blocks_import)
	post("/follow_import", UtilController, :follow_import)
	end
	end

	scope "/oauth", Pleroma.Web.OAuth do
	scope [] do
	pipe_through(:oauth)
	get("/authorize", OAuthController, :authorize)
	end

	post("/authorize", OAuthController, :create_authorization)
	post("/token", OAuthController, :token_exchange)
	post("/revoke", OAuthController, :token_revoke)
	get("/registration_details", OAuthController, :registration_details)

	scope [] do
	pipe_through(:browser)

	get("/prepare_request", OAuthController, :prepare_request)
	get("/:provider", OAuthController, :request)
	get("/:provider/callback", OAuthController, :callback)
	post("/register", OAuthController, :register)
	end
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	scope [] do
	pipe_through(:authenticated_api)
	pipe_through(:oauth_read)
	get("/conversations/:id/statuses", PleromaAPIController, :conversation_statuses)
	get("/conversations/:id", PleromaAPIController, :conversation)
	end

	scope [] do
	pipe_through(:authenticated_api)
	pipe_through(:oauth_write)
	patch("/conversations/:id", PleromaAPIController, :update_conversation)
	post("/notifications/read", PleromaAPIController, :read_notification)

	patch("/accounts/update_avatar", AccountController, :update_avatar)
	patch("/accounts/update_banner", AccountController, :update_banner)
	patch("/accounts/update_background", AccountController, :update_background)

	get("/mascot", MascotController, :show)
	put("/mascot", MascotController, :update)

	post("/scrobble", ScrobbleController, :new_scrobble)
	end

	scope [] do
	pipe_through(:api)
	pipe_through(:oauth_read_or_public)
	get("/accounts/:id/favourites", AccountController, :favourites)
	end

	scope [] do
	pipe_through(:authenticated_api)
	pipe_through(:oauth_follow)

	post("/accounts/:id/subscribe", AccountController, :subscribe)
	post("/accounts/:id/unsubscribe", AccountController, :unsubscribe)
	end

	post("/accounts/confirmation_resend", AccountController, :confirmation_resend)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through([:api, :oauth_read_or_public])

	get("/accounts/:id/scrobbles", ScrobbleController, :user_scrobbles)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:authenticated_api)

	scope [] do
	pipe_through(:oauth_read)

	get("/accounts/verify_credentials", AccountController, :verify_credentials)

	get("/accounts/relationships", AccountController, :relationships)

	get("/accounts/:id/lists", AccountController, :lists)
	get("/accounts/:id/identity_proofs", MastodonAPIController, :empty_array)

	get("/follow_requests", FollowRequestController, :index)
	get("/blocks", MastodonAPIController, :blocks)
	get("/mutes", MastodonAPIController, :mutes)

	get("/timelines/home", TimelineController, :home)
	get("/timelines/direct", TimelineController, :direct)

	get("/favourites", MastodonAPIController, :favourites)
	get("/bookmarks", MastodonAPIController, :bookmarks)

	get("/notifications", NotificationController, :index)
	get("/notifications/:id", NotificationController, :show)
	post("/notifications/clear", NotificationController, :clear)
	post("/notifications/dismiss", NotificationController, :dismiss)
	delete("/notifications/destroy_multiple", NotificationController, :destroy_multiple)

	get("/scheduled_statuses", ScheduledActivityController, :index)
	get("/scheduled_statuses/:id", ScheduledActivityController, :show)

	get("/lists", ListController, :index)
	get("/lists/:id", ListController, :show)
	get("/lists/:id/accounts", ListController, :list_accounts)

	get("/domain_blocks", DomainBlockController, :index)

	get("/filters", FilterController, :index)

	get("/suggestions", SuggestionController, :index)

	get("/conversations", ConversationController, :index)
	post("/conversations/:id/read", ConversationController, :read)

	get("/endorsements", MastodonAPIController, :empty_array)
	end

	scope [] do
	pipe_through(:oauth_write)

	patch("/accounts/update_credentials", AccountController, :update_credentials)

	post("/statuses", StatusController, :create)
	delete("/statuses/:id", StatusController, :delete)

	post("/statuses/:id/reblog", StatusController, :reblog)
	post("/statuses/:id/unreblog", StatusController, :unreblog)
	post("/statuses/:id/favourite", StatusController, :favourite)
	post("/statuses/:id/unfavourite", StatusController, :unfavourite)
	post("/statuses/:id/pin", StatusController, :pin)
	post("/statuses/:id/unpin", StatusController, :unpin)
	post("/statuses/:id/bookmark", StatusController, :bookmark)
	post("/statuses/:id/unbookmark", StatusController, :unbookmark)
	post("/statuses/:id/mute", StatusController, :mute_conversation)
	post("/statuses/:id/unmute", StatusController, :unmute_conversation)

	put("/scheduled_statuses/:id", ScheduledActivityController, :update)
	delete("/scheduled_statuses/:id", ScheduledActivityController, :delete)

	post("/polls/:id/votes", PollController, :vote)

	post("/media", MediaController, :create)
	put("/media/:id", MediaController, :update)

	delete("/lists/:id", ListController, :delete)
	post("/lists", ListController, :create)
	put("/lists/:id", ListController, :update)

	post("/lists/:id/accounts", ListController, :add_to_list)
	delete("/lists/:id/accounts", ListController, :remove_from_list)

	post("/filters", FilterController, :create)
	get("/filters/:id", FilterController, :show)
	put("/filters/:id", FilterController, :update)
	delete("/filters/:id", FilterController, :delete)

	post("/reports", ReportController, :create)
	end

	scope [] do
	pipe_through(:oauth_follow)

	post("/follows", MastodonAPIController, :follows)
	post("/accounts/:id/follow", AccountController, :follow)
	post("/accounts/:id/unfollow", AccountController, :unfollow)
	post("/accounts/:id/block", AccountController, :block)
	post("/accounts/:id/unblock", AccountController, :unblock)
	post("/accounts/:id/mute", AccountController, :mute)
	post("/accounts/:id/unmute", AccountController, :unmute)

	post("/follow_requests/:id/authorize", FollowRequestController, :authorize)
	post("/follow_requests/:id/reject", FollowRequestController, :reject)

	post("/domain_blocks", DomainBlockController, :create)
	delete("/domain_blocks", DomainBlockController, :delete)
	end

	scope [] do
	pipe_through(:oauth_push)

	post("/push/subscription", SubscriptionController, :create)
	get("/push/subscription", SubscriptionController, :get)
	put("/push/subscription", SubscriptionController, :update)
	delete("/push/subscription", SubscriptionController, :delete)
	end
	end

	scope "/api/web", Pleroma.Web do
	pipe_through([:authenticated_api, :oauth_write])

	put("/settings", MastoFEController, :put_settings)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:api)

	post("/accounts", AccountController, :create)
	get("/accounts/search", SearchController, :account_search)

	get("/instance", InstanceController, :show)
	get("/instance/peers", InstanceController, :peers)

	post("/apps", AppController, :create)
	get("/apps/verify_credentials", AppController, :verify_credentials)

	get("/statuses/:id/card", StatusController, :card)
	get("/statuses/:id/favourited_by", StatusController, :favourited_by)
	get("/statuses/:id/reblogged_by", StatusController, :reblogged_by)

	get("/custom_emojis", CustomEmojiController, :index)

	get("/trends", MastodonAPIController, :empty_array)

	scope [] do
	pipe_through(:oauth_read_or_public)

	get("/timelines/public", TimelineController, :public)
	get("/timelines/tag/:tag", TimelineController, :hashtag)
	get("/timelines/list/:list_id", TimelineController, :list)

	get("/statuses", StatusController, :index)
	get("/statuses/:id", StatusController, :show)
	get("/statuses/:id/context", StatusController, :context)

	get("/polls/:id", PollController, :show)

	get("/accounts/:id/statuses", AccountController, :statuses)
	get("/accounts/:id/followers", AccountController, :followers)
	get("/accounts/:id/following", AccountController, :following)
	get("/accounts/:id", AccountController, :show)

	get("/search", SearchController, :search)
	end
	end

	scope "/api/v2", Pleroma.Web.MastodonAPI do
	pipe_through([:api, :oauth_read_or_public])
	get("/search", SearchController, :search2)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:config)

	get("/help/test", TwitterAPI.UtilController, :help_test)
	post("/help/test", TwitterAPI.UtilController, :help_test)
	get("/statusnet/config", TwitterAPI.UtilController, :config)
	get("/statusnet/version", TwitterAPI.UtilController, :version)
	get("/pleroma/frontend_configurations", TwitterAPI.UtilController, :frontend_configurations)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:api)

	get(
	"/account/confirm_email/:user_id/:token",
	TwitterAPI.Controller,
	:confirm_email,
	as: :confirm_email
	)
	end

	scope "/api", Pleroma.Web, as: :authenticated_twitter_api do
	pipe_through(:authenticated_api)

	get("/oauth_tokens", TwitterAPI.Controller, :oauth_tokens)
	delete("/oauth_tokens/:id", TwitterAPI.Controller, :revoke_token)

	scope [] do
	pipe_through(:oauth_read)

	post("/qvitter/statuses/notifications/read", TwitterAPI.Controller, :notifications_read)
	end
	end

	pipeline :ap_service_actor do
	plug(:accepts, ["activity+json", "json"])
	end

	pipeline :ostatus do
	plug(:accepts, ["html", "xml", "atom", "activity+json", "json"])
	end

	pipeline :oembed do
	plug(:accepts, ["json", "xml"])
	end

	scope "/", Pleroma.Web do
	pipe_through(:ostatus)
	pipe_through(:http_signature)

	get("/objects/:uuid", OStatus.OStatusController, :object)
	get("/activities/:uuid", OStatus.OStatusController, :activity)
	get("/notice/:id", OStatus.OStatusController, :notice)
	get("/notice/:id/embed_player", OStatus.OStatusController, :notice_player)
	get("/users/:nickname/feed", OStatus.OStatusController, :feed)
	get("/users/:nickname", OStatus.OStatusController, :feed_redirect)

	post("/users/:nickname/salmon", OStatus.OStatusController, :salmon_incoming)
	post("/push/hub/:nickname", Websub.WebsubController, :websub_subscription_request)
	get("/push/subscriptions/:id", Websub.WebsubController, :websub_subscription_confirmation)
	post("/push/subscriptions/:id", Websub.WebsubController, :websub_incoming)

	get("/mailer/unsubscribe/:token", Mailer.SubscriptionController, :unsubscribe)
	end

	pipeline :activitypub do
	plug(:accepts, ["activity+json", "json"])
	plug(Pleroma.Web.Plugs.HTTPSignaturePlug)
	plug(Pleroma.Web.Plugs.MappedSignatureToIdentityPlug)
	end

	scope "/", Pleroma.Web.ActivityPub do
	# XXX: not really ostatus
	pipe_through(:ostatus)

	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	- get("/objects/:uuid/likes", ActivityPubController, :object_likes)
	end

	pipeline :activitypub_client do
	plug(:accepts, ["activity+json", "json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through([:activitypub_client])

	scope [] do
	pipe_through(:oauth_read)
	get("/api/ap/whoami", ActivityPubController, :whoami)
	get("/users/:nickname/inbox", ActivityPubController, :read_inbox)
	end

	scope [] do
	pipe_through(:oauth_write)
	post("/users/:nickname/outbox", ActivityPubController, :update_outbox)
	post("/api/ap/upload_media", ActivityPubController, :upload_media)
	end

	scope [] do
	pipe_through(:oauth_read_or_public)
	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	end
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through(:activitypub)
	post("/inbox", ActivityPubController, :inbox)
	post("/users/:nickname/inbox", ActivityPubController, :inbox)
	end

	scope "/relay", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :relay)

	scope [] do
	pipe_through(:http_signature)
	post("/inbox", ActivityPubController, :inbox)
	end

	get("/following", ActivityPubController, :following, assigns: %{relay: true})
	get("/followers", ActivityPubController, :followers, assigns: %{relay: true})
	end

	scope "/internal/fetch", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :internal_fetch)
	post("/inbox", ActivityPubController, :inbox)
	end

	scope "/.well-known", Pleroma.Web do
	pipe_through(:well_known)

	get("/host-meta", WebFinger.WebFingerController, :host_meta)
	get("/webfinger", WebFinger.WebFingerController, :webfinger)
	get("/nodeinfo", Nodeinfo.NodeinfoController, :schemas)
	end

	scope "/nodeinfo", Pleroma.Web do
	get("/:version", Nodeinfo.NodeinfoController, :nodeinfo)
	end

	scope "/", Pleroma.Web do
	pipe_through(:mastodon_html)

	get("/web/login", MastodonAPI.AuthController, :login)
	delete("/auth/sign_out", MastodonAPI.AuthController, :logout)

	post("/auth/password", MastodonAPI.AuthController, :password_reset)

	scope [] do
	pipe_through(:oauth_read)
	get("/web/*path", MastoFEController, :index)
	end
	end

	pipeline :remote_media do
	end

	scope "/proxy/", Pleroma.Web.MediaProxy do
	pipe_through(:remote_media)

	get("/:sig/:url", MediaProxyController, :remote)
	get("/:sig/:url/:filename", MediaProxyController, :remote)
	end

	if Pleroma.Config.get(:env) == :dev do
	scope "/dev" do
	pipe_through([:mailbox_preview])

	forward("/mailbox", Plug.Swoosh.MailboxPreview, base_path: "/dev/mailbox")
	end
	end

	scope "/", Pleroma.Web.MongooseIM do
	get("/user_exists", MongooseIMController, :user_exists)
	get("/check_password", MongooseIMController, :check_password)
	end

	scope "/", Fallback do
	get("/registration/:token", RedirectController, :registration_page)
	get("/:maybe_nickname_or_id", RedirectController, :redirector_with_meta)
	get("/api*path", RedirectController, :api_not_implemented)
	get("/*path", RedirectController, :redirector)

	options("/*path", RedirectController, :empty)
	end
	end
	diff --git a/test/web/activity_pub/activity_pub_controller_test.exs b/test/web/activity_pub/activity_pub_controller_test.exs
	index 1ffa91b70..6a3e48b5e 100644
	--- a/test/web/activity_pub/activity_pub_controller_test.exs
	+++ b/test/web/activity_pub/activity_pub_controller_test.exs
	@@ -1,1019 +1,956 @@
	# 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.ActivityPubControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory
	alias Pleroma.Activity
	alias Pleroma.Delivery
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.ReceiverWorker

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

	clear_config_all([:instance, :federating],
	do: Pleroma.Config.put([:instance, :federating], true)
	)

	describe "/relay" do
	clear_config([:instance, :allow_relay])

	test "with the relay active, it returns the relay user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(200)

	assert res["id"] =~ "/relay"
	end

	test "with the relay disabled, it returns 404", %{conn: conn} do
	Pleroma.Config.put([:instance, :allow_relay], false)

	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	\|> assert
	end
	end

	describe "/internal/fetch" do
	test "it returns the internal fetch user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(200)

	assert res["id"] =~ "/fetch"
	end
	end

	describe "/users/:nickname" do
	test "it returns a json representation of the user with accept application/json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/activity+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/ld+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end
	end

	describe "/object/:uuid" do
	test "it returns a json representation of the object with accept application/json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/activity+json",
	%{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/ld+json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns 404 for non-public messages", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it returns 404 for tombstone objects", %{conn: conn} do
	tombstone = insert(:tombstone)
	uuid = String.split(tombstone.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it caches a response", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after object deletion", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Object.delete(note)

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert "Not found" == json_response(conn2, :not_found)
	end
	end

	- describe "/object/:uuid/likes" do
	- setup do
	- like = insert(:like_activity)
	- like_object_ap_id = Object.normalize(like).data["id"]
	-
	- uuid =
	- like_object_ap_id
	- \|> String.split("/")
	- \|> List.last()
	-
	- [id: like.data["id"], uuid: uuid]
	- end
	-
	- test "it returns the like activities in a collection", %{conn: conn, id: id, uuid: uuid} do
	- result =
	- conn
	- \|> put_req_header("accept", "application/activity+json")
	- \|> get("/objects/#{uuid}/likes")
	- \|> json_response(200)
	-
	- assert List.first(result["first"]["orderedItems"])["id"] == id
	- assert result["type"] == "OrderedCollection"
	- assert result["totalItems"] == 1
	- refute result["first"]["next"]
	- end
	-
	- test "it does not crash when page number is exceeded total pages", %{conn: conn, uuid: uuid} do
	- result =
	- conn
	- \|> put_req_header("accept", "application/activity+json")
	- \|> get("/objects/#{uuid}/likes?page=2")
	- \|> json_response(200)
	-
	- assert result["type"] == "OrderedCollectionPage"
	- assert result["totalItems"] == 1
	- refute result["next"]
	- assert Enum.empty?(result["orderedItems"])
	- end
	-
	- test "it contains the next key when likes count is more than 10", %{conn: conn} do
	- note = insert(:note_activity)
	- insert_list(11, :like_activity, note_activity: note)
	-
	- uuid =
	- note
	- \|> Object.normalize()
	- \|> Map.get(:data)
	- \|> Map.get("id")
	- \|> String.split("/")
	- \|> List.last()
	-
	- result =
	- conn
	- \|> put_req_header("accept", "application/activity+json")
	- \|> get("/objects/#{uuid}/likes?page=1")
	- \|> json_response(200)
	-
	- assert result["totalItems"] == 11
	- assert length(result["orderedItems"]) == 10
	- assert result["next"]
	- end
	- end
	-
	describe "/activities/:uuid" do
	test "it returns a json representation of the activity", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end

	test "it returns 404 for non-public activities", %{conn: conn} do
	activity = insert(:direct_note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it caches a response", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after activity deletion", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "cofe"})

	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Activity.delete_by_ap_id(activity.object.data["id"])

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert "Not found" == json_response(conn2, :not_found)
	end
	end

	describe "/inbox" do
	test "it inserts an incoming activity into the database", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	sender_url = data["actor"]
	Instances.set_consistently_unreachable(sender_url)
	refute Instances.reachable?(sender_url)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_url)
	end
	end

	describe "/users/:nickname/inbox" do
	setup do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	[data: data]
	end

	test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
	user = insert(:user)
	data = Map.put(data, "bcc", [user.ap_id])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts messages from actors that are followed by the user", %{
	conn: conn,
	data: data
	} do
	recipient = insert(:user)
	actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})

	{:ok, recipient} = User.follow(recipient, actor)

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

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

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it rejects reads from other users", %{conn: conn} do
	user = insert(:user)
	otheruser = insert(:user)

	conn =
	conn
	\|> assign(:user, otheruser)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(conn, 403)
	end

	test "it doesn't crash without an authenticated user", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(conn, 403)
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
	user = insert(:user)
	data = Map.put(data, "bcc", [user.ap_id])

	sender_host = URI.parse(data["actor"]).host
	Instances.set_consistently_unreachable(sender_host)
	refute Instances.reachable?(sender_host)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_host)
	end

	test "it removes all follower collections but actor's", %{conn: conn} do
	[actor, recipient] = insert_pair(:user)

	data =
	File.read!("test/fixtures/activitypub-client-post-activity.json")
	\|> Poison.decode!()

	object = Map.put(data["object"], "attributedTo", actor.ap_id)

	data =
	data
	\|> Map.put("id", Utils.generate_object_id())
	\|> Map.put("actor", actor.ap_id)
	\|> Map.put("object", object)
	\|> Map.put("cc", [
	recipient.follower_address,
	actor.follower_address
	])
	\|> Map.put("to", [
	recipient.ap_id,
	recipient.follower_address,
	"https://www.w3.org/ns/activitystreams#Public"
	])

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	activity = Activity.get_by_ap_id(data["id"])

	assert activity.id
	assert actor.follower_address in activity.recipients
	assert actor.follower_address in activity.data["cc"]

	refute recipient.follower_address in activity.recipients
	refute recipient.follower_address in activity.data["cc"]
	refute recipient.follower_address in activity.data["to"]
	end
	end

	describe "/users/:nickname/outbox" do
	test "it will not bomb when there is no activity", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox")

	result = json_response(conn, 200)
	assert user.ap_id <> "/outbox" == result["id"]
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it returns an announce activity in a collection", %{conn: conn} do
	announce_activity = insert(:announce_activity)
	user = User.get_cached_by_ap_id(announce_activity.data["actor"])

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ announce_activity.data["object"]
	end

	test "it rejects posts from other users", %{conn: conn} do
	data = File.read!("test/fixtures/activitypub-client-post-activity.json") \|> Poison.decode!()
	user = insert(:user)
	otheruser = insert(:user)

	conn =
	conn
	\|> assign(:user, otheruser)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 403)
	end

	test "it inserts an incoming create activity into the database", %{conn: conn} do
	data = File.read!("test/fixtures/activitypub-client-post-activity.json") \|> Poison.decode!()
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)

	assert Activity.get_by_ap_id(result["id"])
	end

	test "it rejects an incoming activity with bogus type", %{conn: conn} do
	data = File.read!("test/fixtures/activitypub-client-post-activity.json") \|> Poison.decode!()
	user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Delete",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["type"] == "Tombstone"
	end

	test "it rejects delete activity of object from other actor", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = insert(:user)

	data = %{
	type: "Delete",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it increases like count when receiving a like action", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Like",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["like_count"] == 1
	end
	end

	describe "/relay/followers" do
	test "it returns relay followers", %{conn: conn} do
	relay_actor = Relay.get_actor()
	user = insert(:user)
	User.follow(user, relay_actor)

	result =
	conn
	\|> assign(:relay, true)
	\|> get("/relay/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end
	end

	describe "/relay/following" do
	test "it returns relay following", %{conn: conn} do
	result =
	conn
	\|> assign(:relay, true)
	\|> get("/relay/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == []
	end
	end

	describe "/users/:nickname/followers" do
	test "it returns the followers in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "it returns returns a uri if the user has 'hide_followers' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{info: %{hide_followers: true}})
	User.follow(user, user_two)

	result =
	conn
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_followers' set and the request is not authenticated",
	%{conn: conn} do
	user = insert(:user, %{info: %{hide_followers: true}})

	result =
	conn
	\|> get("/users/#{user.nickname}/followers?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_followers' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, %{info: %{hide_followers: true}})
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	other_user = insert(:user)
	User.follow(other_user, user)
	end)

	result =
	conn
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> get("/users/#{user.nickname}/followers?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end
	end

	describe "/users/:nickname/following" do
	test "it returns the following in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user_two.ap_id]
	end

	test "it returns a uri if the user has 'hide_follows' set", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_follows' set and the request is not authenticated",
	%{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})

	result =
	conn
	\|> get("/users/#{user.nickname}/following?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_follows' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	user = User.get_cached_by_id(user.id)
	other_user = insert(:user)
	User.follow(user, other_user)
	end)

	result =
	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> get("/users/#{user.nickname}/following?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end
	end

	describe "delivery tracking" do
	test "it tracks a signed object fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed activity fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed object fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end

	test "it tracks a signed activity fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end
	end

	describe "Additionnal ActivityPub C2S endpoints" do
	test "/api/ap/whoami", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/ap/whoami")

	user = User.get_cached_by_id(user.id)

	assert UserView.render("user.json", %{user: user}) == json_response(conn, 200)
	end

	clear_config([:media_proxy])
	clear_config([Pleroma.Upload])

	test "uploadMedia", %{conn: conn} do
	user = insert(:user)

	desc = "Description of the image"

	image = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})

	assert object = json_response(conn, :created)
	assert object["name"] == desc
	assert object["type"] == "Document"
	assert object["actor"] == user.ap_id
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 2:47 PM (1 d, 6 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798218
Default Alt Text: (97 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions