No OneTemporary
Actions

Authored By

Unknown

Size

216 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/html.ex b/lib/pleroma/html.ex
	index fb602d6b6..bf5daa948 100644
	--- a/lib/pleroma/html.ex
	+++ b/lib/pleroma/html.ex
	@@ -1,231 +1,231 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTML do
	alias HtmlSanitizeEx.Scrubber

	defp get_scrubbers(scrubber) when is_atom(scrubber), do: [scrubber]
	defp get_scrubbers(scrubbers) when is_list(scrubbers), do: scrubbers
	defp get_scrubbers(_), do: [Pleroma.HTML.Scrubber.Default]

	def get_scrubbers() do
	Pleroma.Config.get([:markup, :scrub_policy])
	\|> get_scrubbers
	end

	def filter_tags(html, nil) do
	filter_tags(html, get_scrubbers())
	end

	def filter_tags(html, scrubbers) when is_list(scrubbers) do
	Enum.reduce(scrubbers, html, fn scrubber, html ->
	filter_tags(html, scrubber)
	end)
	end

	def filter_tags(html, scrubber), do: Scrubber.scrub(html, scrubber)
	def filter_tags(html), do: filter_tags(html, nil)
	def strip_tags(html), do: Scrubber.scrub(html, Scrubber.StripTags)

	def get_cached_scrubbed_html_for_object(content, scrubbers, object, module) do
	key = "#{module}#{generate_scrubber_signature(scrubbers)}\|#{object.id}"
	Cachex.fetch!(:scrubber_cache, key, fn _key -> ensure_scrubbed_html(content, scrubbers) end)
	end

	def get_cached_stripped_html_for_object(content, object, module) do
	get_cached_scrubbed_html_for_object(
	content,
	HtmlSanitizeEx.Scrubber.StripTags,
	object,
	module
	)
	end

	def ensure_scrubbed_html(
	content,
	scrubbers
	) do
	{:commit, filter_tags(content, scrubbers)}
	end

	defp generate_scrubber_signature(scrubber) when is_atom(scrubber) do
	generate_scrubber_signature([scrubber])
	end

	defp generate_scrubber_signature(scrubbers) do
	Enum.reduce(scrubbers, "", fn scrubber, signature ->
	"#{signature}#{to_string(scrubber)}"
	end)
	end

	def extract_first_external_url(object, content) do
	key = "URL\|#{object.id}"

	Cachex.fetch!(:scrubber_cache, key, fn _key ->
	result =
	content
	\|> Floki.filter_out("a.mention")
	\|> Floki.attribute("a", "href")
	\|> Enum.at(0)

	- {:commit, result}
	+ {:commit, {:ok, result}}
	end)
	end
	end

	defmodule Pleroma.HTML.Scrubber.TwitterText do
	@moduledoc """
	An HTML scrubbing policy which limits to twitter-style text. Only
	paragraphs, breaks and links are allowed through the filter.
	"""

	@markup Application.get_env(:pleroma, :markup)
	@uri_schemes Application.get_env(:pleroma, :uri_schemes, [])
	@valid_schemes Keyword.get(@uri_schemes, :valid_schemes, [])

	require HtmlSanitizeEx.Scrubber.Meta
	alias HtmlSanitizeEx.Scrubber.Meta

	Meta.remove_cdata_sections_before_scrub()
	Meta.strip_comments()

	# links
	Meta.allow_tag_with_uri_attributes("a", ["href", "data-user", "data-tag"], @valid_schemes)
	Meta.allow_tag_with_these_attributes("a", ["name", "title", "class"])

	# paragraphs and linebreaks
	Meta.allow_tag_with_these_attributes("br", [])
	Meta.allow_tag_with_these_attributes("p", [])

	# microformats
	Meta.allow_tag_with_these_attributes("span", ["class"])

	# allow inline images for custom emoji
	@allow_inline_images Keyword.get(@markup, :allow_inline_images)

	if @allow_inline_images do
	# restrict img tags to http/https only, because of MediaProxy.
	Meta.allow_tag_with_uri_attributes("img", ["src"], ["http", "https"])

	Meta.allow_tag_with_these_attributes("img", [
	"width",
	"height",
	"title",
	"alt"
	])
	end

	Meta.strip_everything_not_covered()
	end

	defmodule Pleroma.HTML.Scrubber.Default do
	@doc "The default HTML scrubbing policy: no "

	require HtmlSanitizeEx.Scrubber.Meta
	alias HtmlSanitizeEx.Scrubber.Meta

	@markup Application.get_env(:pleroma, :markup)
	@uri_schemes Application.get_env(:pleroma, :uri_schemes, [])
	@valid_schemes Keyword.get(@uri_schemes, :valid_schemes, [])

	Meta.remove_cdata_sections_before_scrub()
	Meta.strip_comments()

	Meta.allow_tag_with_uri_attributes("a", ["href", "data-user", "data-tag"], @valid_schemes)
	Meta.allow_tag_with_these_attributes("a", ["name", "title", "class"])

	Meta.allow_tag_with_these_attributes("abbr", ["title"])

	Meta.allow_tag_with_these_attributes("b", [])
	Meta.allow_tag_with_these_attributes("blockquote", [])
	Meta.allow_tag_with_these_attributes("br", [])
	Meta.allow_tag_with_these_attributes("code", [])
	Meta.allow_tag_with_these_attributes("del", [])
	Meta.allow_tag_with_these_attributes("em", [])
	Meta.allow_tag_with_these_attributes("i", [])
	Meta.allow_tag_with_these_attributes("li", [])
	Meta.allow_tag_with_these_attributes("ol", [])
	Meta.allow_tag_with_these_attributes("p", [])
	Meta.allow_tag_with_these_attributes("pre", [])
	Meta.allow_tag_with_these_attributes("span", ["class"])
	Meta.allow_tag_with_these_attributes("strong", [])
	Meta.allow_tag_with_these_attributes("u", [])
	Meta.allow_tag_with_these_attributes("ul", [])

	@allow_inline_images Keyword.get(@markup, :allow_inline_images)

	if @allow_inline_images do
	# restrict img tags to http/https only, because of MediaProxy.
	Meta.allow_tag_with_uri_attributes("img", ["src"], ["http", "https"])

	Meta.allow_tag_with_these_attributes("img", [
	"width",
	"height",
	"title",
	"alt"
	])
	end

	@allow_tables Keyword.get(@markup, :allow_tables)

	if @allow_tables do
	Meta.allow_tag_with_these_attributes("table", [])
	Meta.allow_tag_with_these_attributes("tbody", [])
	Meta.allow_tag_with_these_attributes("td", [])
	Meta.allow_tag_with_these_attributes("th", [])
	Meta.allow_tag_with_these_attributes("thead", [])
	Meta.allow_tag_with_these_attributes("tr", [])
	end

	@allow_headings Keyword.get(@markup, :allow_headings)

	if @allow_headings do
	Meta.allow_tag_with_these_attributes("h1", [])
	Meta.allow_tag_with_these_attributes("h2", [])
	Meta.allow_tag_with_these_attributes("h3", [])
	Meta.allow_tag_with_these_attributes("h4", [])
	Meta.allow_tag_with_these_attributes("h5", [])
	end

	@allow_fonts Keyword.get(@markup, :allow_fonts)

	if @allow_fonts do
	Meta.allow_tag_with_these_attributes("font", ["face"])
	end

	Meta.strip_everything_not_covered()
	end

	defmodule Pleroma.HTML.Transform.MediaProxy do
	@moduledoc "Transforms inline image URIs to use MediaProxy."

	alias Pleroma.Web.MediaProxy

	def before_scrub(html), do: html

	def scrub_attribute("img", {"src", "http" <> target}) do
	media_url =
	("http" <> target)
	\|> MediaProxy.url()

	{"src", media_url}
	end

	def scrub_attribute(_tag, attribute), do: attribute

	def scrub({"img", attributes, children}) do
	attributes =
	attributes
	\|> Enum.map(fn attr -> scrub_attribute("img", attr) end)
	\|> Enum.reject(&is_nil(&1))

	{"img", attributes, children}
	end

	def scrub({:comment, _children}), do: ""

	def scrub({tag, attributes, children}), do: {tag, attributes, children}
	def scrub({_tag, children}), do: children
	def scrub(text), do: text
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index feff22400..0199ac9e7 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,908 +1,912 @@
	# 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(%{"type" => "Create"} = data) do
	to = data["to"] \|\| []
	cc = data["cc"] \|\| []
	actor = data["actor"] \|\| []
	recipients = (to ++ cc ++ [actor]) \|> Enum.uniq()
	{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}}) when not is_nil(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
	})

	+ Task.start(fn ->
	+ Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	+ end)
	+
	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),
	# Changing note count prior to enqueuing federation task in order to avoid race conditions on updating user.info
	{:ok, _actor} <- User.increase_note_count(actor),
	:ok <- maybe_federate(activity) 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),
	# Changing note count prior to enqueuing federation task in order to avoid race conditions on updating user.info
	{:ok, _actor} <- User.decrease_note_count(user),
	:ok <- maybe_federate(activity) 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" => ""}), do: query

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

	defp restrict_since(query, _), do: query

	defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
	when is_list(tag_reject) and tag_reject != [] do
	from(
	activity in query,
	where: fragment("(not (? #> '{\"object\",\"tag\"}') \\?\| ?)", activity.data, ^tag_reject)
	)
	end

	defp restrict_tag_reject(query, _), do: query

	defp restrict_tag_all(query, %{"tag_all" => tag_all})
	when is_list(tag_all) and tag_all != [] do
	from(
	activity in query,
	where: fragment("(? #> '{\"object\",\"tag\"}') \\?& ?", activity.data, ^tag_all)
	)
	end

	defp restrict_tag_all(query, _), do: query

	defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
	from(
	activity in query,
	where: fragment("(? #> '{\"object\",\"tag\"}') \\?\| ?", activity.data, ^tag)
	)
	end

	defp restrict_tag(query, %{"tag" => tag}) when is_binary(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" => ""}), 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_tag_reject(opts)
	\|> restrict_tag_all(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/mastodon_api/mastodon_api_controller.ex b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	index a366a149f..65b612026 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	@@ -1,1386 +1,1381 @@
	# 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.MastodonAPIController do
	use Pleroma.Web, :controller
	alias Pleroma.{Repo, Object, Activity, User, Notification, Stats}
	alias Pleroma.Web
	- alias Pleroma.HTML

	alias Pleroma.Web.MastodonAPI.{
	StatusView,
	AccountView,
	MastodonView,
	ListView,
	FilterView,
	PushSubscriptionView
	}

	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth.{Authorization, Token, App}
	alias Pleroma.Web.MediaProxy

	import Ecto.Query
	require Logger

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

	action_fallback(:errors)

	def create_app(conn, params) do
	with cs <- App.register_changeset(%App{}, params) \|> IO.inspect(),
	{:ok, app} <- Repo.insert(cs) \|> IO.inspect() do
	res = %{
	id: app.id \|> to_string,
	name: app.client_name,
	client_id: app.client_id,
	client_secret: app.client_secret,
	redirect_uri: app.redirect_uris,
	website: app.website
	}

	json(conn, res)
	end
	end

	defp add_if_present(
	map,
	params,
	params_field,
	map_field,
	value_function \\ fn x -> {:ok, x} end
	) do
	if Map.has_key?(params, params_field) do
	case value_function.(params[params_field]) do
	{:ok, new_value} -> Map.put(map, map_field, new_value)
	:error -> map
	end
	else
	map
	end
	end

	def update_credentials(%{assigns: %{user: user}} = conn, params) do
	original_user = user

	user_params =
	%{}
	\|> add_if_present(params, "display_name", :name)
	\|> add_if_present(params, "note", :bio, fn value -> {:ok, User.parse_bio(value)} end)
	\|> add_if_present(params, "avatar", :avatar, fn value ->
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: :avatar) do
	{:ok, object.data}
	else
	_ -> :error
	end
	end)

	info_params =
	%{}
	\|> add_if_present(params, "locked", :locked, fn value -> {:ok, value == "true"} end)
	\|> add_if_present(params, "header", :banner, fn value ->
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: :banner) do
	{:ok, object.data}
	else
	_ -> :error
	end
	end)

	info_cng = User.Info.mastodon_profile_update(user.info, info_params)

	with changeset <- User.update_changeset(user, user_params),
	changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
	{:ok, user} <- User.update_and_set_cache(changeset) do
	if original_user != user do
	CommonAPI.update(user)
	end

	json(conn, AccountView.render("account.json", %{user: user, for: user}))
	else
	_e ->
	conn
	\|> put_status(403)
	\|> json(%{error: "Invalid request"})
	end
	end

	def verify_credentials(%{assigns: %{user: user}} = conn, _) do
	account = AccountView.render("account.json", %{user: user, for: user})
	json(conn, account)
	end

	def user(%{assigns: %{user: for_user}} = conn, %{"id" => id}) do
	with %User{} = user <- Repo.get(User, id),
	true <- User.auth_active?(user) \|\| user.id == for_user.id \|\| User.superuser?(for_user) do
	account = AccountView.render("account.json", %{user: user, for: for_user})
	json(conn, account)
	else
	_e ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Can't find user"})
	end
	end

	@mastodon_api_level "2.5.0"

	def masto_instance(conn, _params) do
	instance = Pleroma.Config.get(:instance)

	response = %{
	uri: Web.base_url(),
	title: Keyword.get(instance, :name),
	description: Keyword.get(instance, :description),
	version: "#{@mastodon_api_level} (compatible; #{Pleroma.Application.named_version()})",
	email: Keyword.get(instance, :email),
	urls: %{
	streaming_api: String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws")
	},
	stats: Stats.get_stats(),
	thumbnail: Web.base_url() <> "/instance/thumbnail.jpeg",
	max_toot_chars: Keyword.get(instance, :limit)
	}

	json(conn, response)
	end

	def peers(conn, _params) do
	json(conn, Stats.get_peers())
	end

	defp mastodonized_emoji do
	Pleroma.Emoji.get_all()
	\|> Enum.map(fn {shortcode, relative_url} ->
	url = to_string(URI.merge(Web.base_url(), relative_url))

	%{
	"shortcode" => shortcode,
	"static_url" => url,
	"visible_in_picker" => true,
	"url" => url
	}
	end)
	end

	def custom_emojis(conn, _params) do
	mastodon_emoji = mastodonized_emoji()
	json(conn, mastodon_emoji)
	end

	defp add_link_headers(conn, method, activities, param \\ nil, params \\ %{}) do
	last = List.last(activities)
	first = List.first(activities)

	if last do
	min = last.id
	max = first.id

	{next_url, prev_url} =
	if param do
	{
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	param,
	Map.merge(params, %{max_id: min})
	),
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	param,
	Map.merge(params, %{since_id: max})
	)
	}
	else
	{
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	Map.merge(params, %{max_id: min})
	),
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	Map.merge(params, %{since_id: max})
	)
	}
	end

	conn
	\|> put_resp_header("link", "<#{next_url}>; rel=\"next\", <#{prev_url}>; rel=\"prev\"")
	else
	conn
	end
	end

	def home_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("blocking_user", user)
	\|> Map.put("user", user)

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

	conn
	\|> add_link_headers(:home_timeline, activities)
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def public_timeline(%{assigns: %{user: user}} = conn, params) do
	local_only = params["local"] in [true, "True", "true", "1"]

	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("local_only", local_only)
	\|> Map.put("blocking_user", user)

	activities =
	ActivityPub.fetch_public_activities(params)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(:public_timeline, activities, false, %{"local" => local_only})
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
	with %User{} = user <- Repo.get(User, params["id"]) do
	activities = ActivityPub.fetch_user_activities(user, reading_user, params)

	conn
	\|> add_link_headers(:user_statuses, activities, params["id"])
	\|> put_view(StatusView)
	\|> render("index.json", %{
	activities: activities,
	for: reading_user,
	as: :activity
	})
	end
	end

	def dm_timeline(%{assigns: %{user: user}} = conn, params) do
	query =
	ActivityPub.fetch_activities_query(
	[user.ap_id],
	Map.merge(params, %{"type" => "Create", visibility: "direct"})
	)

	activities = Repo.all(query)

	conn
	\|> add_link_headers(:dm_timeline, activities)
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def get_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Repo.get(Activity, id),
	true <- ActivityPub.visible_for_user?(activity, user) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user})
	end
	end

	def get_context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Repo.get(Activity, id),
	activities <-
	ActivityPub.fetch_activities_for_context(activity.data["context"], %{
	"blocking_user" => user,
	"user" => user
	}),
	activities <-
	activities \|> Enum.filter(fn %{id: aid} -> to_string(aid) != to_string(id) end),
	activities <-
	activities \|> Enum.filter(fn %{data: %{"type" => type}} -> type == "Create" end),
	grouped_activities <- Enum.group_by(activities, fn %{id: id} -> id < activity.id end) do
	result = %{
	ancestors:
	StatusView.render(
	"index.json",
	for: user,
	activities: grouped_activities[true] \|\| [],
	as: :activity
	)
	\|> Enum.reverse(),
	descendants:
	StatusView.render(
	"index.json",
	for: user,
	activities: grouped_activities[false] \|\| [],
	as: :activity
	)
	\|> Enum.reverse()
	}

	json(conn, result)
	end
	end

	def post_status(conn, %{"status" => "", "media_ids" => media_ids} = params)
	when length(media_ids) > 0 do
	params =
	params
	\|> Map.put("status", ".")

	post_status(conn, params)
	end

	def post_status(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
	params =
	params
	\|> Map.put("in_reply_to_status_id", params["in_reply_to_id"])

	idempotency_key =
	case get_req_header(conn, "idempotency-key") do
	[key] -> key
	_ -> Ecto.UUID.generate()
	end

	{:ok, activity} =
	Cachex.fetch!(:idempotency_cache, idempotency_key, fn _ -> CommonAPI.post(user, params) end)

	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end

	def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	json(conn, %{})
	else
	_e ->
	conn
	\|> put_status(403)
	\|> json(%{error: "Can't delete this post"})
	end
	end

	def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: announce, for: user, as: :activity})
	end
	end

	def unreblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def fav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def unfav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def pin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	else
	{:error, reason} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(:bad_request, Jason.encode!(%{"error" => reason}))
	end
	end

	def unpin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def notifications(%{assigns: %{user: user}} = conn, params) do
	notifications = Notification.for_user(user, params)

	result =
	Enum.map(notifications, fn x ->
	render_notification(user, x)
	end)
	\|> Enum.filter(& &1)

	conn
	\|> add_link_headers(:notifications, notifications)
	\|> json(result)
	end

	def get_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
	with {:ok, notification} <- Notification.get(user, id) do
	json(conn, render_notification(user, notification))
	else
	{:error, reason} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => reason}))
	end
	end

	def clear_notifications(%{assigns: %{user: user}} = conn, _params) do
	Notification.clear(user)
	json(conn, %{})
	end

	def dismiss_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
	with {:ok, _notif} <- Notification.dismiss(user, id) do
	json(conn, %{})
	else
	{:error, reason} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => reason}))
	end
	end

	def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	id = List.wrap(id)
	q = from(u in User, where: u.id in ^id)
	targets = Repo.all(q)

	conn
	\|> put_view(AccountView)
	\|> render("relationships.json", %{user: user, targets: targets})
	end

	# Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array.
	def relationships(%{assigns: %{user: _user}} = conn, _), do: json(conn, [])

	def update_media(%{assigns: %{user: user}} = conn, data) do
	with %Object{} = object <- Repo.get(Object, data["id"]),
	true <- Object.authorize_mutation(object, user),
	true <- is_binary(data["description"]),
	description <- data["description"] do
	new_data = %{object.data \| "name" => description}

	{:ok, _} =
	object
	\|> Object.change(%{data: new_data})
	\|> Repo.update()

	attachment_data = Map.put(new_data, "id", object.id)

	conn
	\|> put_view(StatusView)
	\|> render("attachment.json", %{attachment: attachment_data})
	end
	end

	def upload(%{assigns: %{user: user}} = conn, %{"file" => file} = data) do
	with {:ok, object} <-
	- ActivityPub.upload(file,
	+ ActivityPub.upload(
	+ file,
	actor: User.ap_id(user),
	description: Map.get(data, "description")
	) do
	attachment_data = Map.put(object.data, "id", object.id)

	conn
	\|> put_view(StatusView)
	\|> render("attachment.json", %{attachment: attachment_data})
	end
	end

	def favourited_by(conn, %{"id" => id}) do
	with %Activity{data: %{"object" => %{"likes" => likes}}} <- Repo.get(Activity, id) do
	q = from(u in User, where: u.ap_id in ^likes)
	users = Repo.all(q)

	conn
	\|> put_view(AccountView)
	\|> render(AccountView, "accounts.json", %{users: users, as: :user})
	else
	_ -> json(conn, [])
	end
	end

	def reblogged_by(conn, %{"id" => id}) do
	with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Repo.get(Activity, id) do
	q = from(u in User, where: u.ap_id in ^announces)
	users = Repo.all(q)

	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: users, as: :user})
	else
	_ -> json(conn, [])
	end
	end

	def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
	local_only = params["local"] in [true, "True", "true", "1"]

	tags =
	[params["tag"], params["any"]]
	\|> List.flatten()
	\|> Enum.uniq()
	\|> Enum.filter(& &1)
	\|> Enum.map(&String.downcase(&1))

	tag_all =
	params["all"] \|\|
	[]
	\|> Enum.map(&String.downcase(&1))

	tag_reject =
	params["none"] \|\|
	[]
	\|> Enum.map(&String.downcase(&1))

	query_params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("local_only", local_only)
	\|> Map.put("blocking_user", user)
	\|> Map.put("tag", tags)
	\|> Map.put("tag_all", tag_all)
	\|> Map.put("tag_reject", tag_reject)

	activities =
	ActivityPub.fetch_public_activities(query_params)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(:hashtag_timeline, activities, params["tag"], %{"local" => local_only})
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id}) do
	with %User{} = user <- Repo.get(User, id),
	{:ok, followers} <- User.get_followers(user) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_network -> []
	true -> followers
	end

	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: followers, as: :user})
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"id" => id}) do
	with %User{} = user <- Repo.get(User, id),
	{:ok, followers} <- User.get_friends(user) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_network -> []
	true -> followers
	end

	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: followers, as: :user})
	end
	end

	def follow_requests(%{assigns: %{user: followed}} = conn, _params) do
	with {:ok, follow_requests} <- User.get_follow_requests(followed) do
	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: follow_requests, as: :user})
	end
	end

	def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
	with %User{} = follower <- Repo.get(User, id),
	{:ok, follower} <- User.maybe_follow(follower, followed),
	%Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
	{:ok, _activity} <-
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed.ap_id,
	object: follow_activity.data["id"],
	type: "Accept"
	}) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: followed, target: follower})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
	with %User{} = follower <- Repo.get(User, id),
	%Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
	{:ok, _activity} <-
	ActivityPub.reject(%{
	to: [follower.ap_id],
	actor: followed.ap_id,
	object: follow_activity.data["id"],
	type: "Reject"
	}) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: followed, target: follower})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
	with %User{} = followed <- Repo.get(User, id),
	{:ok, follower} <- User.maybe_direct_follow(follower, followed),
	{:ok, _activity} <- ActivityPub.follow(follower, followed),
	{:ok, follower, followed} <-
	User.wait_and_refresh(
	Pleroma.Config.get([:activitypub, :follow_handshake_timeout]),
	follower,
	followed
	) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
	with %User{} = followed <- Repo.get_by(User, nickname: uri),
	{:ok, follower} <- User.maybe_direct_follow(follower, followed),
	{:ok, _activity} <- ActivityPub.follow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("account.json", %{user: followed, for: follower})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
	with %User{} = followed <- Repo.get(User, id),
	{:ok, _activity} <- ActivityPub.unfollow(follower, followed),
	{:ok, follower, _} <- User.unfollow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})
	end
	end

	def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
	with %User{} = blocked <- Repo.get(User, id),
	{:ok, blocker} <- User.block(blocker, blocked),
	{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: blocker, target: blocked})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
	with %User{} = blocked <- Repo.get(User, id),
	{:ok, blocker} <- User.unblock(blocker, blocked),
	{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: blocker, target: blocked})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def blocks(%{assigns: %{user: user}} = conn, _) do
	with blocked_accounts <- User.blocked_users(user) do
	res = AccountView.render("accounts.json", users: blocked_accounts, for: user, as: :user)
	json(conn, res)
	end
	end

	def domain_blocks(%{assigns: %{user: %{info: info}}} = conn, _) do
	json(conn, info.domain_blocks \|\| [])
	end

	def block_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
	User.block_domain(blocker, domain)
	json(conn, %{})
	end

	def unblock_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
	User.unblock_domain(blocker, domain)
	json(conn, %{})
	end

	def status_search(user, query) do
	fetched =
	if Regex.match?(~r/https?:/, query) do
	with {:ok, object} <- ActivityPub.fetch_object_from_id(query),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
	true <- ActivityPub.visible_for_user?(activity, user) do
	[activity]
	else
	_e -> []
	end
	end \|\| []

	q =
	from(
	a in Activity,
	where: fragment("?->>'type' = 'Create'", a.data),
	where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
	where:
	fragment(
	"to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
	a.data,
	^query
	),
	limit: 20,
	order_by: [desc: :id]
	)

	Repo.all(q) ++ fetched
	end

	def search2(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	accounts = User.search(query, params["resolve"] == "true", user)

	statuses = status_search(user, query)

	tags_path = Web.base_url() <> "/tag/"

	tags =
	String.split(query)
	\|> Enum.uniq()
	\|> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
	\|> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
	\|> Enum.map(fn tag -> %{name: tag, url: tags_path <> tag} end)

	res = %{
	"accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
	"statuses" =>
	StatusView.render("index.json", activities: statuses, for: user, as: :activity),
	"hashtags" => tags
	}

	json(conn, res)
	end

	def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	accounts = User.search(query, params["resolve"] == "true", user)

	statuses = status_search(user, query)

	tags =
	String.split(query)
	\|> Enum.uniq()
	\|> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
	\|> Enum.map(fn tag -> String.slice(tag, 1..-1) end)

	res = %{
	"accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
	"statuses" =>
	StatusView.render("index.json", activities: statuses, for: user, as: :activity),
	"hashtags" => tags
	}

	json(conn, res)
	end

	def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	accounts = User.search(query, params["resolve"] == "true", user)

	res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)

	json(conn, res)
	end

	def favourites(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("favorited_by", user.ap_id)
	\|> Map.put("blocking_user", user)

	activities =
	ActivityPub.fetch_public_activities(params)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(:favourites, activities)
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def get_lists(%{assigns: %{user: user}} = conn, opts) do
	lists = Pleroma.List.for_user(user, opts)
	res = ListView.render("lists.json", lists: lists)
	json(conn, res)
	end

	def get_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user) do
	res = ListView.render("list.json", list: list)
	json(conn, res)
	else
	_e -> json(conn, "error")
	end
	end

	def account_lists(%{assigns: %{user: user}} = conn, %{"id" => account_id}) do
	lists = Pleroma.List.get_lists_account_belongs(user, account_id)
	res = ListView.render("lists.json", lists: lists)
	json(conn, res)
	end

	def delete_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	{:ok, _list} <- Pleroma.List.delete(list) do
	json(conn, %{})
	else
	_e ->
	json(conn, "error")
	end
	end

	def create_list(%{assigns: %{user: user}} = conn, %{"title" => title}) do
	with {:ok, %Pleroma.List{} = list} <- Pleroma.List.create(title, user) do
	res = ListView.render("list.json", list: list)
	json(conn, res)
	end
	end

	def add_to_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
	accounts
	\|> Enum.each(fn account_id ->
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	%User{} = followed <- Repo.get(User, account_id) do
	Pleroma.List.follow(list, followed)
	end
	end)

	json(conn, %{})
	end

	def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
	accounts
	\|> Enum.each(fn account_id ->
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	%User{} = followed <- Repo.get(Pleroma.User, account_id) do
	Pleroma.List.unfollow(list, followed)
	end
	end)

	json(conn, %{})
	end

	def list_accounts(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	{:ok, users} = Pleroma.List.get_following(list) do
	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: users, as: :user})
	end
	end

	def rename_list(%{assigns: %{user: user}} = conn, %{"id" => id, "title" => title}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	{:ok, list} <- Pleroma.List.rename(list, title) do
	res = ListView.render("list.json", list: list)
	json(conn, res)
	else
	_e ->
	json(conn, "error")
	end
	end

	def list_timeline(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params) do
	with %Pleroma.List{title: _title, following: following} <- Pleroma.List.get(id, user) do
	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("blocking_user", user)

	# we must filter the following list for the user to avoid leaking statuses the user
	# does not actually have permission to see (for more info, peruse security issue #270).
	following_to =
	following
	\|> Enum.filter(fn x -> x in user.following end)

	activities =
	ActivityPub.fetch_activities_bounded(following_to, following, params)
	\|> Enum.reverse()

	conn
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	else
	_e ->
	conn
	\|> put_status(403)
	\|> json(%{error: "Error."})
	end
	end

	def index(%{assigns: %{user: user}} = conn, _params) do
	token =
	conn
	\|> get_session(:oauth_token)

	if user && token do
	mastodon_emoji = mastodonized_emoji()

	limit = Pleroma.Config.get([:instance, :limit])

	accounts =
	Map.put(%{}, user.id, AccountView.render("account.json", %{user: user, for: user}))

	initial_state =
	%{
	meta: %{
	streaming_api_base_url:
	String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws"),
	access_token: token,
	locale: "en",
	domain: Pleroma.Web.Endpoint.host(),
	admin: "1",
	me: "#{user.id}",
	unfollow_modal: false,
	boost_modal: false,
	delete_modal: true,
	auto_play_gif: false,
	display_sensitive_media: false,
	reduce_motion: false,
	max_toot_chars: limit
	},
	rights: %{
	delete_others_notice: !!user.info.is_moderator,
	admin: !!user.info.is_admin
	},
	compose: %{
	me: "#{user.id}",
	default_privacy: user.info.default_scope,
	default_sensitive: false
	},
	media_attachments: %{
	accept_content_types: [
	".jpg",
	".jpeg",
	".png",
	".gif",
	".webm",
	".mp4",
	".m4v",
	"image\/jpeg",
	"image\/png",
	"image\/gif",
	"video\/webm",
	"video\/mp4"
	]
	},
	settings:
	user.info.settings \|\|
	%{
	onboarded: true,
	home: %{
	shows: %{
	reblog: true,
	reply: true
	}
	},
	notifications: %{
	alerts: %{
	follow: true,
	favourite: true,
	reblog: true,
	mention: true
	},
	shows: %{
	follow: true,
	favourite: true,
	reblog: true,
	mention: true
	},
	sounds: %{
	follow: true,
	favourite: true,
	reblog: true,
	mention: true
	}
	}
	},
	push_subscription: nil,
	accounts: accounts,
	custom_emojis: mastodon_emoji,
	char_limit: limit
	}
	\|> Jason.encode!()

	conn
	\|> put_layout(false)
	\|> put_view(MastodonView)
	\|> render("index.html", %{initial_state: initial_state})
	else
	conn
	\|> redirect(to: "/web/login")
	end
	end

	def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
	info_cng = User.Info.mastodon_settings_update(user.info, settings)

	with changeset <- Ecto.Changeset.change(user),
	changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	json(conn, %{})
	else
	e ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(500, Jason.encode!(%{"error" => inspect(e)}))
	end
	end

	def login(conn, %{"code" => code}) do
	with {:ok, app} <- get_or_make_app(),
	%Authorization{} = auth <- Repo.get_by(Authorization, token: code, app_id: app.id),
	{:ok, token} <- Token.exchange_token(app, auth) do
	conn
	\|> put_session(:oauth_token, token.token)
	\|> redirect(to: "/web/getting-started")
	end
	end

	def login(conn, _) do
	with {:ok, app} <- get_or_make_app() do
	path =
	- o_auth_path(conn, :authorize,
	+ o_auth_path(
	+ conn,
	+ :authorize,
	response_type: "code",
	client_id: app.client_id,
	redirect_uri: ".",
	scope: app.scopes
	)

	conn
	\|> redirect(to: path)
	end
	end

	defp get_or_make_app() do
	with %App{} = app <- Repo.get_by(App, client_name: "Mastodon-Local") do
	{:ok, app}
	else
	_e ->
	cs =
	App.register_changeset(%App{}, %{
	client_name: "Mastodon-Local",
	redirect_uris: ".",
	scopes: "read,write,follow"
	})

	Repo.insert(cs)
	end
	end

	def logout(conn, _) do
	conn
	\|> clear_session
	\|> redirect(to: "/")
	end

	def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	Logger.debug("Unimplemented, returning unmodified relationship")

	with %User{} = target <- Repo.get(User, id) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: user, target: target})
	end
	end

	def empty_array(conn, _) do
	Logger.debug("Unimplemented, returning an empty array")
	json(conn, [])
	end

	def empty_object(conn, _) do
	Logger.debug("Unimplemented, returning an empty object")
	json(conn, %{})
	end

	def render_notification(user, %{id: id, activity: activity, inserted_at: created_at} = _params) do
	actor = User.get_cached_by_ap_id(activity.data["actor"])
	parent_activity = Activity.get_create_by_object_ap_id(activity.data["object"])
	mastodon_type = Activity.mastodon_notification_type(activity)

	response = %{
	id: to_string(id),
	type: mastodon_type,
	created_at: CommonAPI.Utils.to_masto_date(created_at),
	account: AccountView.render("account.json", %{user: actor, for: user})
	}

	case mastodon_type do
	"mention" ->
	response
	\|> Map.merge(%{
	status: StatusView.render("status.json", %{activity: activity, for: user})
	})

	"favourite" ->
	response
	\|> Map.merge(%{
	status: StatusView.render("status.json", %{activity: parent_activity, for: user})
	})

	"reblog" ->
	response
	\|> Map.merge(%{
	status: StatusView.render("status.json", %{activity: parent_activity, for: user})
	})

	"follow" ->
	response

	_ ->
	nil
	end
	end

	def get_filters(%{assigns: %{user: user}} = conn, _) do
	filters = Pleroma.Filter.get_filters(user)
	res = FilterView.render("filters.json", filters: filters)
	json(conn, res)
	end

	def create_filter(
	%{assigns: %{user: user}} = conn,
	%{"phrase" => phrase, "context" => context} = params
	) do
	query = %Pleroma.Filter{
	user_id: user.id,
	phrase: phrase,
	context: context,
	hide: Map.get(params, "irreversible", nil),
	whole_word: Map.get(params, "boolean", true)
	# expires_at
	}

	{:ok, response} = Pleroma.Filter.create(query)
	res = FilterView.render("filter.json", filter: response)
	json(conn, res)
	end

	def get_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
	filter = Pleroma.Filter.get(filter_id, user)
	res = FilterView.render("filter.json", filter: filter)
	json(conn, res)
	end

	def update_filter(
	%{assigns: %{user: user}} = conn,
	%{"phrase" => phrase, "context" => context, "id" => filter_id} = params
	) do
	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: filter_id,
	phrase: phrase,
	context: context,
	hide: Map.get(params, "irreversible", nil),
	whole_word: Map.get(params, "boolean", true)
	# expires_at
	}

	{:ok, response} = Pleroma.Filter.update(query)
	res = FilterView.render("filter.json", filter: response)
	json(conn, res)
	end

	def delete_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: filter_id
	}

	{:ok, _} = Pleroma.Filter.delete(query)
	json(conn, %{})
	end

	def create_push_subscription(%{assigns: %{user: user, token: token}} = conn, params) do
	true = Pleroma.Web.Push.enabled()
	Pleroma.Web.Push.Subscription.delete_if_exists(user, token)
	{:ok, subscription} = Pleroma.Web.Push.Subscription.create(user, token, params)
	view = PushSubscriptionView.render("push_subscription.json", subscription: subscription)
	json(conn, view)
	end

	def get_push_subscription(%{assigns: %{user: user, token: token}} = conn, _params) do
	true = Pleroma.Web.Push.enabled()
	subscription = Pleroma.Web.Push.Subscription.get(user, token)
	view = PushSubscriptionView.render("push_subscription.json", subscription: subscription)
	json(conn, view)
	end

	def update_push_subscription(
	%{assigns: %{user: user, token: token}} = conn,
	params
	) do
	true = Pleroma.Web.Push.enabled()
	{:ok, subscription} = Pleroma.Web.Push.Subscription.update(user, token, params)
	view = PushSubscriptionView.render("push_subscription.json", subscription: subscription)
	json(conn, view)
	end

	def delete_push_subscription(%{assigns: %{user: user, token: token}} = conn, _params) do
	true = Pleroma.Web.Push.enabled()
	{:ok, _response} = Pleroma.Web.Push.Subscription.delete(user, token)
	json(conn, %{})
	end

	def errors(conn, _) do
	conn
	\|> put_status(500)
	\|> json("Something went wrong")
	end

	def suggestions(%{assigns: %{user: user}} = conn, _) do
	suggestions = Pleroma.Config.get(:suggestions)

	if Keyword.get(suggestions, :enabled, false) do
	api = Keyword.get(suggestions, :third_party_engine, "")
	timeout = Keyword.get(suggestions, :timeout, 5000)
	limit = Keyword.get(suggestions, :limit, 23)

	host = Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host])

	user = user.nickname
	url = String.replace(api, "{{host}}", host) \|> String.replace("{{user}}", user)

	with {:ok, %{status: 200, body: body}} <-
	@httpoison.get(
	url,
	[],
	adapter: [
	timeout: timeout,
	recv_timeout: timeout
	]
	),
	{:ok, data} <- Jason.decode(body) do
	data2 =
	Enum.slice(data, 0, limit)
	\|> Enum.map(fn x ->
	Map.put(
	x,
	"id",
	case User.get_or_fetch(x["acct"]) do
	%{id: id} -> id
	_ -> 0
	end
	)
	end)
	\|> Enum.map(fn x ->
	Map.put(x, "avatar", MediaProxy.url(x["avatar"]))
	end)
	\|> Enum.map(fn x ->
	Map.put(x, "avatar_static", MediaProxy.url(x["avatar_static"]))
	end)

	conn
	\|> json(data2)
	else
	e -> Logger.error("Could not retrieve suggestions at fetch #{url}, #{inspect(e)}")
	end
	else
	json(conn, [])
	end
	end

	- def get_status_card(status_id) do
	+ def status_card(conn, %{"id" => status_id}) do
	with %Activity{} = activity <- Repo.get(Activity, status_id),
	- true <- ActivityPub.is_public?(activity),
	- %Object{} = object <- Object.normalize(activity.data["object"]),
	- page_url <- HTML.extract_first_external_url(object, object.data["content"]),
	- {:ok, rich_media} <- Pleroma.Web.RichMedia.Parser.parse(page_url) do
	- page_url = rich_media[:url] \|\| page_url
	- site_name = rich_media[:site_name] \|\| URI.parse(page_url).host
	-
	- rich_media
	- \|> Map.take([:image, :title, :description])
	- \|> Map.put(:type, "link")
	- \|> Map.put(:provider_name, site_name)
	- \|> Map.put(:url, page_url)
	+ true <- ActivityPub.is_public?(activity) do
	+ data =
	+ StatusView.render(
	+ "card.json",
	+ Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	+ )
	+
	+ json(conn, data)
	else
	- _ -> %{}
	+ _e ->
	+ %{}
	end
	end

	- def status_card(conn, %{"id" => status_id}) do
	- json(conn, get_status_card(status_id))
	- end
	-
	def try_render(conn, target, params)
	when is_binary(target) do
	res = render(conn, target, params)

	if res == nil do
	conn
	\|> put_status(501)
	\|> json(%{error: "Can't display this activity"})
	else
	res
	end
	end

	def try_render(conn, _, _) do
	conn
	\|> put_status(501)
	\|> json(%{error: "Can't display this activity"})
	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 ddfe6788c..b14ca9f5d 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,318 +1,344 @@
	# 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_by_object_ap_id()
	\|> 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
	\|> safe_render_many(
	StatusView,
	"status.json",
	Map.put(opts, :replied_to_activities, replied_to_activities)
	)
	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_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__
	)

	+ card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))
	+
	%{
	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,
	+ card: card,
	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("card.json", %{rich_media: rich_media, page_url: page_url}) do
	+ page_url = rich_media[:url] \|\| page_url
	+ page_url_data = URI.parse(page_url)
	+ site_name = rich_media[:site_name] \|\| page_url_data.host
	+
	+ %{
	+ type: "link",
	+ provider_name: site_name,
	+ provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
	+ url: page_url,
	+ image: rich_media[:image] \|> MediaProxy.url(),
	+ title: rich_media[:title],
	+ description: rich_media[:description],
	+ pleroma: %{
	+ opengraph: rich_media
	+ }
	+ }
	+ end
	+
	+ def render("card.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_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/lib/pleroma/web/rich_media/controllers/rich_media_controller.ex b/lib/pleroma/web/rich_media/controllers/rich_media_controller.ex
	deleted file mode 100644
	index 91019961d..000000000
	--- a/lib/pleroma/web/rich_media/controllers/rich_media_controller.ex
	+++ /dev/null
	@@ -1,17 +0,0 @@
	-defmodule Pleroma.Web.RichMedia.RichMediaController do
	- use Pleroma.Web, :controller
	-
	- import Pleroma.Web.ControllerHelper, only: [json_response: 3]
	-
	- def parse(conn, %{"url" => url}) do
	- case Pleroma.Web.RichMedia.Parser.parse(url) do
	- {:ok, data} ->
	- conn
	- \|> json_response(200, data)
	-
	- {:error, msg} ->
	- conn
	- \|> json_response(404, msg)
	- end
	- end
	-end
	diff --git a/lib/pleroma/web/rich_media/helpers.ex b/lib/pleroma/web/rich_media/helpers.ex
	new file mode 100644
	index 000000000..71fdddef9
	--- /dev/null
	+++ b/lib/pleroma/web/rich_media/helpers.ex
	@@ -0,0 +1,18 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright _ 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.RichMedia.Helpers do
	+ alias Pleroma.{Activity, Object, HTML}
	+ alias Pleroma.Web.RichMedia.Parser
	+
	+ def fetch_data_for_activity(%Activity{} = activity) do
	+ with %Object{} = object <- Object.normalize(activity.data["object"]),
	+ {:ok, page_url} <- HTML.extract_first_external_url(object, object.data["content"]),
	+ {:ok, rich_media} <- Parser.parse(page_url) do
	+ %{page_url: page_url, rich_media: rich_media}
	+ else
	+ _ -> %{}
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/rich_media/parser.ex b/lib/pleroma/web/rich_media/parser.ex
	index 947dc0c3c..76d977ac2 100644
	--- a/lib/pleroma/web/rich_media/parser.ex
	+++ b/lib/pleroma/web/rich_media/parser.ex
	@@ -1,45 +1,56 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.RichMedia.Parser do
	@parsers [
	Pleroma.Web.RichMedia.Parsers.OGP,
	Pleroma.Web.RichMedia.Parsers.TwitterCard,
	Pleroma.Web.RichMedia.Parsers.OEmbed
	]

	def parse(nil), do: {:error, "No URL provided"}

	if Mix.env() == :test do
	def parse(url), do: parse_url(url)
	else
	def parse(url) do
	- with {:ok, data} <- Cachex.fetch(:rich_media_cache, url, fn _ -> parse_url(url) end) do
	- data
	- else
	- _e ->
	- {:error, "Parsing error"}
	+ try do
	+ Cachex.fetch!(:rich_media_cache, url, fn _ ->
	+ {:commit, parse_url(url)}
	+ end)
	+ rescue
	+ e ->
	+ {:error, "Cachex error: #{inspect(e)}"}
	end
	end
	end

	defp parse_url(url) do
	- {:ok, %Tesla.Env{body: html}} = Pleroma.HTTP.get(url)
	+ try do
	+ {:ok, %Tesla.Env{body: html}} = Pleroma.HTTP.get(url)

	- html \|> maybe_parse() \|> get_parsed_data()
	+ html \|> maybe_parse() \|> get_parsed_data()
	+ rescue
	+ e ->
	+ {:error, "Parsing error: #{inspect(e)}"}
	+ end
	end

	defp maybe_parse(html) do
	Enum.reduce_while(@parsers, %{}, fn parser, acc ->
	case parser.parse(html, acc) do
	{:ok, data} -> {:halt, data}
	{:error, _msg} -> {:cont, acc}
	end
	end)
	end

	- defp get_parsed_data(data) when data == %{} do
	- {:error, "No metadata found"}
	+ defp get_parsed_data(%{title: title} = data) when is_binary(title) and byte_size(title) > 0 do
	+ {:ok, data}
	end

	defp get_parsed_data(data) do
	- {:ok, data}
	+ {:error, "Found metadata was invalid or incomplete: #{inspect(data)}"}
	end
	end
	diff --git a/lib/pleroma/web/rich_media/parsers/oembed_parser.ex b/lib/pleroma/web/rich_media/parsers/oembed_parser.ex
	index ca7226faf..efa98bc2c 100644
	--- a/lib/pleroma/web/rich_media/parsers/oembed_parser.ex
	+++ b/lib/pleroma/web/rich_media/parsers/oembed_parser.ex
	@@ -1,27 +1,31 @@
	defmodule Pleroma.Web.RichMedia.Parsers.OEmbed do
	def parse(html, _data) do
	with elements = [_ \| _] <- get_discovery_data(html),
	{:ok, oembed_url} <- get_oembed_url(elements),
	{:ok, oembed_data} <- get_oembed_data(oembed_url) do
	{:ok, oembed_data}
	else
	_e -> {:error, "No OEmbed data found"}
	end
	end

	defp get_discovery_data(html) do
	html \|> Floki.find("link[type='application/json+oembed']")
	end

	defp get_oembed_url(nodes) do
	{"link", attributes, _children} = nodes \|> hd()

	{:ok, Enum.into(attributes, %{})["href"]}
	end

	defp get_oembed_data(url) do
	{:ok, %Tesla.Env{body: json}} = Pleroma.HTTP.get(url)

	- {:ok, Poison.decode!(json)}
	+ {:ok, data} = Jason.decode(json)
	+
	+ data = data \|> Map.new(fn {k, v} -> {String.to_atom(k), v} end)
	+
	+ {:ok, data}
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index 31f739738..68e7a44b6 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,564 +1,558 @@
	# 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 :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)
	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)
	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)
	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 :well_known do
	plug(:accepts, ["json", "jrd+json", "xml", "xrd+xml"])
	end

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

	pipeline :oauth do
	plug(:accepts, ["html", "json"])
	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

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_api)
	get("/password_reset/:token", UtilController, :show_password_reset)
	post("/password_reset", UtilController, :password_reset)
	get("/emoji", UtilController, :emoji)
	get("/captcha", UtilController, :captcha)
	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)
	delete("/user", AdminAPIController, :user_delete)
	post("/user", AdminAPIController, :user_create)
	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)

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

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

	get("/invite_token", AdminAPIController, :get_invite_token)
	post("/email_invite", AdminAPIController, :email_invite)

	get("/password_reset", AdminAPIController, :get_password_reset)
	end

	scope "/", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_html)
	get("/ostatus_subscribe", UtilController, :remote_follow)
	post("/ostatus_subscribe", UtilController, :do_remote_follow)
	post("/main/ostatus", UtilController, :remote_subscribe)
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:authenticated_api)
	post("/blocks_import", UtilController, :blocks_import)
	post("/follow_import", UtilController, :follow_import)
	post("/change_password", UtilController, :change_password)
	post("/delete_account", UtilController, :delete_account)
	end

	scope "/oauth", Pleroma.Web.OAuth do
	get("/authorize", OAuthController, :authorize)
	post("/authorize", OAuthController, :create_authorization)
	post("/token", OAuthController, :token_exchange)
	post("/revoke", OAuthController, :token_revoke)
	end

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

	patch("/accounts/update_credentials", MastodonAPIController, :update_credentials)
	get("/accounts/verify_credentials", MastodonAPIController, :verify_credentials)
	get("/accounts/relationships", MastodonAPIController, :relationships)
	get("/accounts/search", MastodonAPIController, :account_search)
	post("/accounts/:id/follow", MastodonAPIController, :follow)
	post("/accounts/:id/unfollow", MastodonAPIController, :unfollow)
	post("/accounts/:id/block", MastodonAPIController, :block)
	post("/accounts/:id/unblock", MastodonAPIController, :unblock)
	post("/accounts/:id/mute", MastodonAPIController, :relationship_noop)
	post("/accounts/:id/unmute", MastodonAPIController, :relationship_noop)
	get("/accounts/:id/lists", MastodonAPIController, :account_lists)

	get("/follow_requests", MastodonAPIController, :follow_requests)
	post("/follow_requests/:id/authorize", MastodonAPIController, :authorize_follow_request)
	post("/follow_requests/:id/reject", MastodonAPIController, :reject_follow_request)

	post("/follows", MastodonAPIController, :follow)

	get("/blocks", MastodonAPIController, :blocks)

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

	get("/timelines/home", MastodonAPIController, :home_timeline)

	get("/timelines/direct", MastodonAPIController, :dm_timeline)

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

	post("/statuses", MastodonAPIController, :post_status)
	delete("/statuses/:id", MastodonAPIController, :delete_status)

	post("/statuses/:id/reblog", MastodonAPIController, :reblog_status)
	post("/statuses/:id/unreblog", MastodonAPIController, :unreblog_status)
	post("/statuses/:id/favourite", MastodonAPIController, :fav_status)
	post("/statuses/:id/unfavourite", MastodonAPIController, :unfav_status)
	post("/statuses/:id/pin", MastodonAPIController, :pin_status)
	post("/statuses/:id/unpin", MastodonAPIController, :unpin_status)

	post("/notifications/clear", MastodonAPIController, :clear_notifications)
	post("/notifications/dismiss", MastodonAPIController, :dismiss_notification)
	get("/notifications", MastodonAPIController, :notifications)
	get("/notifications/:id", MastodonAPIController, :get_notification)

	post("/media", MastodonAPIController, :upload)
	put("/media/:id", MastodonAPIController, :update_media)

	get("/lists", MastodonAPIController, :get_lists)
	get("/lists/:id", MastodonAPIController, :get_list)
	delete("/lists/:id", MastodonAPIController, :delete_list)
	post("/lists", MastodonAPIController, :create_list)
	put("/lists/:id", MastodonAPIController, :rename_list)
	get("/lists/:id/accounts", MastodonAPIController, :list_accounts)
	post("/lists/:id/accounts", MastodonAPIController, :add_to_list)
	delete("/lists/:id/accounts", MastodonAPIController, :remove_from_list)

	get("/domain_blocks", MastodonAPIController, :domain_blocks)
	post("/domain_blocks", MastodonAPIController, :block_domain)
	delete("/domain_blocks", MastodonAPIController, :unblock_domain)

	get("/filters", MastodonAPIController, :get_filters)
	post("/filters", MastodonAPIController, :create_filter)
	get("/filters/:id", MastodonAPIController, :get_filter)
	put("/filters/:id", MastodonAPIController, :update_filter)
	delete("/filters/:id", MastodonAPIController, :delete_filter)

	post("/push/subscription", MastodonAPIController, :create_push_subscription)
	get("/push/subscription", MastodonAPIController, :get_push_subscription)
	put("/push/subscription", MastodonAPIController, :update_push_subscription)
	delete("/push/subscription", MastodonAPIController, :delete_push_subscription)

	get("/suggestions", MastodonAPIController, :suggestions)

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

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

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

	- scope "/api", Pleroma.Web.RichMedia do
	- pipe_through(:authenticated_api)
	-
	- get("/rich_media/parse", RichMediaController, :parse)
	- end
	-
	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:api)
	get("/instance", MastodonAPIController, :masto_instance)
	get("/instance/peers", MastodonAPIController, :peers)
	post("/apps", MastodonAPIController, :create_app)
	get("/custom_emojis", MastodonAPIController, :custom_emojis)

	get("/timelines/public", MastodonAPIController, :public_timeline)
	get("/timelines/tag/:tag", MastodonAPIController, :hashtag_timeline)
	get("/timelines/list/:list_id", MastodonAPIController, :list_timeline)

	get("/statuses/:id", MastodonAPIController, :get_status)
	get("/statuses/:id/context", MastodonAPIController, :get_context)
	get("/statuses/:id/card", MastodonAPIController, :status_card)
	get("/statuses/:id/favourited_by", MastodonAPIController, :favourited_by)
	get("/statuses/:id/reblogged_by", MastodonAPIController, :reblogged_by)

	get("/accounts/:id/statuses", MastodonAPIController, :user_statuses)
	get("/accounts/:id/followers", MastodonAPIController, :followers)
	get("/accounts/:id/following", MastodonAPIController, :following)
	get("/accounts/:id", MastodonAPIController, :user)

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

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

	scope "/api/v2", Pleroma.Web.MastodonAPI do
	pipe_through(:api)
	get("/search", MastodonAPIController, :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)
	end

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

	get("/statuses/user_timeline", TwitterAPI.Controller, :user_timeline)
	get("/qvitter/statuses/user_timeline", TwitterAPI.Controller, :user_timeline)
	get("/users/show", TwitterAPI.Controller, :show_user)

	get("/statuses/followers", TwitterAPI.Controller, :followers)
	get("/statuses/friends", TwitterAPI.Controller, :friends)
	get("/statuses/blocks", TwitterAPI.Controller, :blocks)
	get("/statuses/show/:id", TwitterAPI.Controller, :fetch_status)
	get("/statusnet/conversation/:id", TwitterAPI.Controller, :fetch_conversation)

	post("/account/register", TwitterAPI.Controller, :register)
	post("/account/password_reset", TwitterAPI.Controller, :password_reset)

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

	post("/account/resend_confirmation_email", TwitterAPI.Controller, :resend_confirmation_email)

	get("/search", TwitterAPI.Controller, :search)
	get("/statusnet/tags/timeline/:tag", TwitterAPI.Controller, :public_and_external_timeline)
	end

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

	get("/statuses/public_timeline", TwitterAPI.Controller, :public_timeline)

	get(
	"/statuses/public_and_external_timeline",
	TwitterAPI.Controller,
	:public_and_external_timeline
	)

	get("/statuses/networkpublic_timeline", TwitterAPI.Controller, :public_and_external_timeline)
	end

	scope "/api", Pleroma.Web, as: :twitter_api_search do
	pipe_through(:api)
	get("/pleroma/search_user", TwitterAPI.Controller, :search_user)
	end

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

	get("/account/verify_credentials", TwitterAPI.Controller, :verify_credentials)
	post("/account/verify_credentials", TwitterAPI.Controller, :verify_credentials)

	post("/account/update_profile", TwitterAPI.Controller, :update_profile)
	post("/account/update_profile_banner", TwitterAPI.Controller, :update_banner)
	post("/qvitter/update_background_image", TwitterAPI.Controller, :update_background)

	get("/statuses/home_timeline", TwitterAPI.Controller, :friends_timeline)
	get("/statuses/friends_timeline", TwitterAPI.Controller, :friends_timeline)
	get("/statuses/mentions", TwitterAPI.Controller, :mentions_timeline)
	get("/statuses/mentions_timeline", TwitterAPI.Controller, :mentions_timeline)
	get("/statuses/dm_timeline", TwitterAPI.Controller, :dm_timeline)
	get("/qvitter/statuses/notifications", TwitterAPI.Controller, :notifications)

	# XXX: this is really a pleroma API, but we want to keep the pleroma namespace clean
	# for now.
	post("/qvitter/statuses/notifications/read", TwitterAPI.Controller, :notifications_read)

	post("/statuses/update", TwitterAPI.Controller, :status_update)
	post("/statuses/retweet/:id", TwitterAPI.Controller, :retweet)
	post("/statuses/unretweet/:id", TwitterAPI.Controller, :unretweet)
	post("/statuses/destroy/:id", TwitterAPI.Controller, :delete_post)

	post("/statuses/pin/:id", TwitterAPI.Controller, :pin)
	post("/statuses/unpin/:id", TwitterAPI.Controller, :unpin)

	get("/pleroma/friend_requests", TwitterAPI.Controller, :friend_requests)
	post("/pleroma/friendships/approve", TwitterAPI.Controller, :approve_friend_request)
	post("/pleroma/friendships/deny", TwitterAPI.Controller, :deny_friend_request)

	post("/friendships/create", TwitterAPI.Controller, :follow)
	post("/friendships/destroy", TwitterAPI.Controller, :unfollow)
	post("/blocks/create", TwitterAPI.Controller, :block)
	post("/blocks/destroy", TwitterAPI.Controller, :unblock)

	post("/statusnet/media/upload", TwitterAPI.Controller, :upload)
	post("/media/upload", TwitterAPI.Controller, :upload_json)
	post("/media/metadata/create", TwitterAPI.Controller, :update_media)

	post("/favorites/create/:id", TwitterAPI.Controller, :favorite)
	post("/favorites/create", TwitterAPI.Controller, :favorite)
	post("/favorites/destroy/:id", TwitterAPI.Controller, :unfavorite)

	post("/qvitter/update_avatar", TwitterAPI.Controller, :update_avatar)

	get("/friends/ids", TwitterAPI.Controller, :friends_ids)
	get("/friendships/no_retweets/ids", TwitterAPI.Controller, :empty_array)

	get("/mutes/users/ids", TwitterAPI.Controller, :empty_array)
	get("/qvitter/mutes", TwitterAPI.Controller, :raw_empty_array)

	get("/externalprofile/show", TwitterAPI.Controller, :external_profile)
	end

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

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

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

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

	get("/objects/:uuid", OStatus.OStatusController, :object)
	get("/activities/:uuid", OStatus.OStatusController, :activity)
	get("/notice/:id", OStatus.OStatusController, :notice)
	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)
	end

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

	get("/oembed", OEmbed.OEmbedController, :url)
	end

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

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

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

	pipeline :activitypub_client do
	plug(:accepts, ["activity+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])

	get("/users/:nickname/inbox", ActivityPubController, :read_inbox)
	post("/users/:nickname/outbox", ActivityPubController, :update_outbox)
	end

	scope "/relay", Pleroma.Web.ActivityPub do
	pipe_through(:ap_relay)
	get("/", ActivityPubController, :relay)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through(:activitypub)
	post("/users/:nickname/inbox", ActivityPubController, :inbox)
	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.MastodonAPI do
	pipe_through(:mastodon_html)

	get("/web/login", MastodonAPIController, :login)
	post("/web/login", MastodonAPIController, :login_post)
	get("/web/*path", MastodonAPIController, :index)
	delete("/auth/sign_out", MastodonAPIController, :logout)
	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 Mix.env() == :dev do
	scope "/dev" do
	pipe_through([:mailbox_preview])

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

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

	options("/*path", RedirectController, :empty)
	end
	end

	defmodule Fallback.RedirectController do
	use Pleroma.Web, :controller
	alias Pleroma.Web.Metadata
	alias Pleroma.User

	def redirector(conn, _params, code \\ 200) do
	conn
	\|> put_resp_content_type("text/html")
	\|> send_file(code, index_file_path())
	end

	def redirector_with_meta(conn, %{"maybe_nickname_or_id" => maybe_nickname_or_id} = params) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(maybe_nickname_or_id) do
	redirector_with_meta(conn, %{user: user})
	else
	nil ->
	redirector(conn, params)
	end
	end

	def redirector_with_meta(conn, params) do
	{:ok, index_content} = File.read(index_file_path())
	tags = Metadata.build_tags(params)
	response = String.replace(index_content, "<!--server-generated-meta-->", tags)

	conn
	\|> put_resp_content_type("text/html")
	\|> send_resp(200, response)
	end

	def index_file_path do
	Pleroma.Plugs.InstanceStatic.file_path("index.html")
	end

	def registration_page(conn, params) do
	redirector(conn, params)
	end

	def empty(conn, _params) do
	conn
	\|> put_status(204)
	\|> text("")
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/representers/activity_representer.ex b/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	index 19b723586..c4025cbd7 100644
	--- a/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	+++ b/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	@@ -1,240 +1,248 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	# THIS MODULE IS DEPRECATED! DON'T USE IT!
	# USE THE Pleroma.Web.TwitterAPI.Views.ActivityView MODULE!
	defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter do
	use Pleroma.Web.TwitterAPI.Representers.BaseRepresenter
	alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
	alias Pleroma.{Activity, User}
	alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView, ActivityView}
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Formatter
	alias Pleroma.HTML
	+ alias Pleroma.Web.MastodonAPI.StatusView

	defp user_by_ap_id(user_list, ap_id) do
	Enum.find(user_list, fn %{ap_id: user_id} -> ap_id == user_id end)
	end

	def to_map(
	%Activity{data: %{"type" => "Announce", "actor" => actor, "published" => created_at}} =
	activity,
	%{users: users, announced_activity: announced_activity} = opts
	) do
	user = user_by_ap_id(users, actor)
	created_at = created_at \|> Utils.date_to_asctime()

	text = "#{user.nickname} retweeted a status."

	announced_user = user_by_ap_id(users, announced_activity.data["actor"])
	retweeted_status = to_map(announced_activity, Map.merge(%{user: announced_user}, opts))

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=note",
	"created_at" => created_at,
	"retweeted_status" => retweeted_status,
	"statusnet_conversation_id" => conversation_id(announced_activity),
	"external_url" => activity.data["id"],
	"activity_type" => "repeat"
	}
	end

	def to_map(
	%Activity{data: %{"type" => "Like", "published" => created_at}} = activity,
	%{user: user, liked_activity: liked_activity} = opts
	) do
	created_at = created_at \|> Utils.date_to_asctime()

	text = "#{user.nickname} favorited a status."

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=Favourite",
	"created_at" => created_at,
	"in_reply_to_status_id" => liked_activity.id,
	"external_url" => activity.data["id"],
	"activity_type" => "like"
	}
	end

	def to_map(
	%Activity{data: %{"type" => "Follow", "object" => followed_id}} = activity,
	%{user: user} = opts
	) do
	created_at = activity.data["published"] \|\| DateTime.to_iso8601(activity.inserted_at)
	created_at = created_at \|> Utils.date_to_asctime()

	followed = User.get_cached_by_ap_id(followed_id)
	text = "#{user.nickname} started following #{followed.nickname}"

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "follow"
	}
	end

	# TODO:
	# Make this more proper. Just a placeholder to not break the frontend.
	def to_map(
	%Activity{
	data: %{"type" => "Undo", "published" => created_at, "object" => undid_activity}
	} = activity,
	%{user: user} = opts
	) do
	created_at = created_at \|> Utils.date_to_asctime()

	text = "#{user.nickname} undid the action at #{undid_activity["id"]}"

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "undo"
	}
	end

	def to_map(
	%Activity{data: %{"type" => "Delete", "published" => created_at, "object" => _}} =
	activity,
	%{user: user} = opts
	) do
	created_at = created_at \|> Utils.date_to_asctime()

	%{
	"id" => activity.id,
	"uri" => activity.data["object"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => "deleted notice {{tag",
	"text" => "deleted notice {{tag",
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "delete"
	}
	end

	def to_map(
	%Activity{data: %{"object" => %{"content" => _content} = object}} = activity,
	%{user: user} = opts
	) do
	created_at = object["published"] \|> Utils.date_to_asctime()
	like_count = object["like_count"] \|\| 0
	announcement_count = object["announcement_count"] \|\| 0
	favorited = opts[:for] && opts[:for].ap_id in (object["likes"] \|\| [])
	repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] \|\| [])
	pinned = activity.id in user.info.pinned_activities

	mentions = opts[:mentioned] \|\| []

	attentions =
	[]
	\|> Utils.maybe_notify_to_recipients(activity)
	\|> Utils.maybe_notify_mentioned_recipients(activity)
	\|> Enum.map(fn ap_id -> Enum.find(mentions, fn user -> ap_id == user.ap_id end) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> UserView.render("show.json", %{user: user, for: opts[:for]}) end)

	conversation_id = conversation_id(activity)

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

	tags = if possibly_sensitive, do: Enum.uniq(["nsfw" \| tags]), else: tags

	{_summary, content} = ActivityView.render_content(object)

	html =
	HTML.filter_tags(content, User.html_filter_policy(opts[:for]))
	\|> Formatter.emojify(object["emoji"])

	attachments = object["attachment"] \|\| []

	reply_parent = Activity.get_in_reply_to_activity(activity)

	reply_user = reply_parent && User.get_cached_by_ap_id(reply_parent.actor)

	summary = HTML.strip_tags(object["summary"])

	+ card =
	+ StatusView.render(
	+ "card.json",
	+ Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	+ )
	+
	%{
	"id" => activity.id,
	"uri" => activity.data["object"]["id"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => html,
	"text" => HTML.strip_tags(content),
	"is_local" => activity.local,
	"is_post_verb" => true,
	"created_at" => created_at,
	"in_reply_to_status_id" => object["inReplyToStatusId"],
	"in_reply_to_screen_name" => reply_user && reply_user.nickname,
	"in_reply_to_profileurl" => User.profile_url(reply_user),
	"in_reply_to_ostatus_uri" => reply_user && reply_user.ap_id,
	"in_reply_to_user_id" => reply_user && reply_user.id,
	"statusnet_conversation_id" => conversation_id,
	"attachments" => attachments \|> ObjectRepresenter.enum_to_list(opts),
	"attentions" => attentions,
	"fave_num" => like_count,
	"repeat_num" => announcement_count,
	"favorited" => to_boolean(favorited),
	"repeated" => to_boolean(repeated),
	"pinned" => pinned,
	"external_url" => object["external_url"] \|\| object["id"],
	"tags" => tags,
	"activity_type" => "post",
	"possibly_sensitive" => possibly_sensitive,
	"visibility" => Pleroma.Web.MastodonAPI.StatusView.get_visibility(object),
	"summary" => summary,
	- "summary_html" => summary \|> Formatter.emojify(object["emoji"])
	+ "summary_html" => summary \|> Formatter.emojify(object["emoji"]),
	+ "card" => card
	}
	end

	def conversation_id(activity) do
	with context when not is_nil(context) <- activity.data["context"] do
	TwitterAPI.context_to_conversation_id(context)
	else
	_e -> nil
	end
	end

	defp to_boolean(false) do
	false
	end

	defp to_boolean(nil) do
	false
	end

	defp to_boolean(_) do
	true
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/views/activity_view.ex b/lib/pleroma/web/twitter_api/views/activity_view.ex
	index a01ee0010..d0d1221c3 100644
	--- a/lib/pleroma/web/twitter_api/views/activity_view.ex
	+++ b/lib/pleroma/web/twitter_api/views/activity_view.ex
	@@ -1,347 +1,355 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.ActivityView do
	use Pleroma.Web, :view
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.User
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
	+ alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Repo
	alias Pleroma.Formatter

	import Ecto.Query
	require Logger

	defp query_context_ids([]), do: []

	defp query_context_ids(contexts) do
	query = from(o in Object, where: fragment("(?)->>'id' = ANY(?)", o.data, ^contexts))

	Repo.all(query)
	end

	defp query_users([]), do: []

	defp query_users(user_ids) do
	query = from(user in User, where: user.ap_id in ^user_ids)

	Repo.all(query)
	end

	defp collect_context_ids(activities) do
	_contexts =
	activities
	\|> Enum.reject(& &1.data["context_id"])
	\|> Enum.map(fn %{data: data} ->
	data["context"]
	end)
	\|> Enum.filter(& &1)
	\|> query_context_ids()
	\|> Enum.reduce(%{}, fn %{data: %{"id" => ap_id}, id: id}, acc ->
	Map.put(acc, ap_id, id)
	end)
	end

	defp collect_users(activities) do
	activities
	\|> Enum.map(fn activity ->
	case activity.data do
	data = %{"type" => "Follow"} ->
	[data["actor"], data["object"]]

	data ->
	[data["actor"]]
	end ++ activity.recipients
	end)
	\|> List.flatten()
	\|> Enum.uniq()
	\|> query_users()
	\|> Enum.reduce(%{}, fn user, acc ->
	Map.put(acc, user.ap_id, user)
	end)
	end

	defp get_context_id(%{data: %{"context_id" => context_id}}, _) when not is_nil(context_id),
	do: context_id

	defp get_context_id(%{data: %{"context" => nil}}, _), do: nil

	defp get_context_id(%{data: %{"context" => context}}, options) do
	cond do
	id = options[:context_ids][context] -> id
	true -> TwitterAPI.context_to_conversation_id(context)
	end
	end

	defp get_context_id(_, _), do: nil

	defp get_user(ap_id, opts) do
	cond do
	user = opts[:users][ap_id] ->
	user

	String.ends_with?(ap_id, "/followers") ->
	nil

	ap_id == "https://www.w3.org/ns/activitystreams#Public" ->
	nil

	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
	context_ids = collect_context_ids(opts.activities)
	users = collect_users(opts.activities)

	opts =
	opts
	\|> Map.put(:context_ids, context_ids)
	\|> Map.put(:users, users)

	safe_render_many(
	opts.activities,
	ActivityView,
	"activity.json",
	opts
	)
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Delete"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|> Utils.date_to_asctime()

	%{
	"id" => activity.id,
	"uri" => activity.data["object"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => "deleted notice {{tag",
	"text" => "deleted notice {{tag",
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "delete"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Follow"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|\| DateTime.to_iso8601(activity.inserted_at)
	created_at = created_at \|> Utils.date_to_asctime()

	followed = get_user(activity.data["object"], opts)
	text = "#{user.nickname} started following #{followed.nickname}"

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "follow"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Announce"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|> Utils.date_to_asctime()
	announced_activity = Activity.get_create_by_object_ap_id(activity.data["object"])

	text = "#{user.nickname} retweeted a status."

	retweeted_status = render("activity.json", Map.merge(opts, %{activity: announced_activity}))

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=note",
	"created_at" => created_at,
	"retweeted_status" => retweeted_status,
	"statusnet_conversation_id" => get_context_id(announced_activity, opts),
	"external_url" => activity.data["id"],
	"activity_type" => "repeat"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Like"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	liked_activity = Activity.get_create_by_object_ap_id(activity.data["object"])
	liked_activity_id = if liked_activity, do: liked_activity.id, else: nil

	created_at =
	activity.data["published"]
	\|> Utils.date_to_asctime()

	text = "#{user.nickname} favorited a status."

	favorited_status =
	if liked_activity,
	do: render("activity.json", Map.merge(opts, %{activity: liked_activity})),
	else: nil

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=Favourite",
	"created_at" => created_at,
	"favorited_status" => favorited_status,
	"in_reply_to_status_id" => liked_activity_id,
	"external_url" => activity.data["id"],
	"activity_type" => "like"
	}
	end

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

	created_at = object["published"] \|> Utils.date_to_asctime()
	like_count = object["like_count"] \|\| 0
	announcement_count = object["announcement_count"] \|\| 0
	favorited = opts[:for] && opts[:for].ap_id in (object["likes"] \|\| [])
	repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] \|\| [])
	pinned = activity.id in user.info.pinned_activities

	attentions =
	[]
	\|> Utils.maybe_notify_to_recipients(activity)
	\|> Utils.maybe_notify_mentioned_recipients(activity)
	\|> Enum.map(fn ap_id -> get_user(ap_id, opts) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> UserView.render("show.json", %{user: user, for: opts[:for]}) end)

	conversation_id = get_context_id(activity, opts)

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

	tags = if possibly_sensitive, do: Enum.uniq(["nsfw" \| tags]), else: tags

	{summary, content} = render_content(object)

	html =
	content
	\|> HTML.get_cached_scrubbed_html_for_object(
	User.html_filter_policy(opts[:for]),
	activity,
	__MODULE__
	)
	\|> Formatter.emojify(object["emoji"])

	text =
	if content do
	content
	\|> String.replace(~r/<br\s?\/?>/, "\n")
	\|> HTML.get_cached_stripped_html_for_object(activity, __MODULE__)
	end

	reply_parent = Activity.get_in_reply_to_activity(activity)

	reply_user = reply_parent && User.get_cached_by_ap_id(reply_parent.actor)

	summary = HTML.strip_tags(summary)

	+ card =
	+ StatusView.render(
	+ "card.json",
	+ Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	+ )
	+
	%{
	"id" => activity.id,
	"uri" => activity.data["object"]["id"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => html,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => true,
	"created_at" => created_at,
	"in_reply_to_status_id" => object["inReplyToStatusId"],
	"in_reply_to_screen_name" => reply_user && reply_user.nickname,
	"in_reply_to_profileurl" => User.profile_url(reply_user),
	"in_reply_to_ostatus_uri" => reply_user && reply_user.ap_id,
	"in_reply_to_user_id" => reply_user && reply_user.id,
	"statusnet_conversation_id" => conversation_id,
	"attachments" => (object["attachment"] \|\| []) \|> ObjectRepresenter.enum_to_list(opts),
	"attentions" => attentions,
	"fave_num" => like_count,
	"repeat_num" => announcement_count,
	"favorited" => !!favorited,
	"repeated" => !!repeated,
	"pinned" => pinned,
	"external_url" => object["external_url"] \|\| object["id"],
	"tags" => tags,
	"activity_type" => "post",
	"possibly_sensitive" => possibly_sensitive,
	- "visibility" => Pleroma.Web.MastodonAPI.StatusView.get_visibility(object),
	+ "visibility" => StatusView.get_visibility(object),
	"summary" => summary,
	- "summary_html" => summary \|> Formatter.emojify(object["emoji"])
	+ "summary_html" => summary \|> Formatter.emojify(object["emoji"]),
	+ "card" => card
	}
	end

	def render("activity.json", %{activity: unhandled_activity}) do
	Logger.warn("#{__MODULE__} unhandled activity: #{inspect(unhandled_activity)}")
	nil
	end

	def render_content(%{"type" => "Note"} = object) do
	summary = object["summary"]

	content =
	if !!summary and summary != "" do
	"<p>#{summary}</p>#{object["content"]}"
	else
	object["content"]
	end

	{summary, content}
	end

	def render_content(%{"type" => object_type} = object)
	when object_type in ["Article", "Page", "Video"] do
	summary = object["name"] \|\| object["summary"]

	content =
	if !!summary and summary != "" and is_bitstring(object["url"]) do
	"<p><a href=\"#{object["url"]}\">#{summary}</a></p>#{object["content"]}"
	else
	object["content"]
	end

	{summary, content}
	end

	def render_content(object) do
	summary = object["summary"] \|\| "Unhandled activity type: #{object["type"]}"
	content = "<p>#{summary}</p>#{object["content"]}"

	{summary, content}
	end
	end
	diff --git a/test/web/mastodon_api/mastodon_api_controller_test.exs b/test/web/mastodon_api/mastodon_api_controller_test.exs
	index b8f901e6c..1a5eb090c 100644
	--- a/test/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,1672 +1,1696 @@
	# 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.MastodonAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.{Repo, User, Object, Activity, Notification}
	alias Pleroma.Web.{OStatus, CommonAPI}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.MastodonAPI.FilterView
	alias Ecto.Changeset
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock

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

	test "the home timeline", %{conn: conn} do
	user = insert(:user)
	following = insert(:user)

	{:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	assert length(json_response(conn, 200)) == 0

	{:ok, user} = User.follow(user, following)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end

	test "the public timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	conn =
	conn
	\|> get("/api/v1/timelines/public", %{"local" => "False"})

	assert length(json_response(conn, 200)) == 2

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "True"})

	assert [%{"content" => "test"}] = json_response(conn, 200)

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "1"})

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end)
	end

	test "posting a status", %{conn: conn} do
	user = insert(:user)

	idempotency_key = "Pikachu rocks!"

	conn_one =
	conn
	\|> assign(:user, user)
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	{:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
	# Six hours
	assert ttl > :timer.seconds(6 * 60 * 60 - 1)

	assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
	json_response(conn_one, 200)

	assert Repo.get(Activity, id)

	conn_two =
	conn
	\|> assign(:user, user)
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => second_id} = json_response(conn_two, 200)

	assert id == second_id

	conn_three =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => third_id} = json_response(conn_three, 200)

	refute id == third_id
	end

	test "posting a sensitive status", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})

	assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
	assert Repo.get(Activity, id)
	end

	+ test "posting a status with OGP link preview", %{conn: conn} do
	+ user = insert(:user)
	+
	+ conn =
	+ conn
	+ \|> assign(:user, user)
	+ \|> post("/api/v1/statuses", %{
	+ "status" => "http://example.com/ogp"
	+ })
	+
	+ assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
	+ assert Repo.get(Activity, id)
	+ end
	+
	test "posting a direct status", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	content = "direct cofe @#{user2.nickname}"

	conn =
	conn
	\|> assign(:user, user1)
	\|> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})

	assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
	assert activity = Repo.get(Activity, id)
	assert activity.recipients == [user2.ap_id, user1.ap_id]
	assert activity.data["to"] == [user2.ap_id]
	assert activity.data["cc"] == []
	end

	test "direct timeline", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	{:ok, user_two} = User.follow(user_two, user_one)

	{:ok, direct} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})

	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "private"
	})

	# Only direct should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status
	assert status["url"] != direct.data["id"]

	# User should be able to see his own direct message
	res_conn =
	build_conn()
	\|> assign(:user, user_one)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status

	# Both should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/home")

	[_s1, _s2] = json_response(res_conn, 200)

	# Test pagination
	Enum.each(1..20, fn _ ->
	{:ok, _} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})
	end)

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	statuses = json_response(res_conn, 200)
	assert length(statuses) == 20

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})

	[status] = json_response(res_conn, 200)

	assert status["url"] != direct.data["id"]
	end

	test "replying to a status", %{conn: conn} do
	user = insert(:user)

	{:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Repo.get(Activity, id)

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

	test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Repo.get(Activity, id)

	assert activity
	end

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "verify_credentials default scope unlisted", %{conn: conn} do
	user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "get a status", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(activity.id)
	end

	describe "deleting a status" do
	test "when you created it", %{conn: conn} do
	activity = insert(:note_activity)
	author = User.get_by_ap_id(activity.data["actor"])

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response(conn, 200)

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

	test "when you didn't create it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{"error" => _} = json_response(conn, 403)

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

	describe "filters" do
	test "creating a filter", %{conn: conn} do
	user = insert(:user)

	filter = %Pleroma.Filter{
	phrase: "knights",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})

	assert response = json_response(conn, 200)
	assert response["phrase"] == filter.phrase
	assert response["context"] == filter.context
	assert response["id"] != nil
	assert response["id"] != ""
	end

	test "fetching a list of filters", %{conn: conn} do
	user = insert(:user)

	query_one = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 1,
	phrase: "knights",
	context: ["home"]
	}

	query_two = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "who",
	context: ["home"]
	}

	{:ok, filter_one} = Pleroma.Filter.create(query_one)
	{:ok, filter_two} = Pleroma.Filter.create(query_two)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters")
	\|> json_response(200)

	assert response ==
	render_json(
	FilterView,
	"filters.json",
	filters: [filter_two, filter_one]
	)
	end

	test "get a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters/#{filter.filter_id}")

	assert _response = json_response(conn, 200)
	end

	test "update a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, _filter} = Pleroma.Filter.create(query)

	new = %Pleroma.Filter{
	phrase: "nii",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/filters/#{query.filter_id}", %{
	phrase: new.phrase,
	context: new.context
	})

	assert response = json_response(conn, 200)
	assert response["phrase"] == new.phrase
	assert response["context"] == new.context
	end

	test "delete a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/filters/#{filter.filter_id}")

	assert response = json_response(conn, 200)
	assert response == %{}
	end
	end

	describe "lists" do
	test "creating a list", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists", %{"title" => "cuties"})

	assert %{"title" => title} = json_response(conn, 200)
	assert title == "cuties"
	end

	test "adding users to a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [other_user.follower_address]
	end

	test "removing users from a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)
	{:ok, list} = Pleroma.List.follow(list, third_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [third_user.follower_address]
	end

	test "listing users in a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "retrieving a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(list.id)
	end

	test "renaming a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})

	assert %{"title" => name} = json_response(conn, 200)
	assert name == "newname"
	end

	test "deleting a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}")

	assert %{} = json_response(conn, 200)
	assert is_nil(Repo.get(Pleroma.List, list.id))
	end

	test "list timeline", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
	{:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response(conn, 200)

	assert id == to_string(activity_two.id)
	end

	test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})

	{:ok, _activity_two} =
	TwitterAPI.create_status(other_user, %{
	"status" => "Marisa is cute.",
	"visibility" => "private"
	})

	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response(conn, 200)

	assert id == to_string(activity_one.id)
	end
	end

	describe "notifications" do
	test "list of notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\">@<span>#{user.nickname}</span></a></span>"

	assert [%{"status" => %{"content" => response}} \| _rest] = json_response(conn, 200)
	assert response == expected_response
	end

	test "getting a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications/#{notification.id}")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\">@<span>#{user.nickname}</span></a></span>"

	assert %{"status" => %{"content" => response}} = json_response(conn, 200)
	assert response == expected_response
	end

	test "dismissing a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/dismiss", %{"id" => notification.id})

	assert %{} = json_response(conn, 200)
	end

	test "clearing all notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/clear")

	assert %{} = json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	assert all = json_response(conn, 200)
	assert all == []
	end
	end

	describe "reblogging" do
	test "reblogs and returns the reblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "unreblogging" do
	test "unreblogs and returns the unreblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unreblog")

	assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "favoriting" do
	test "favs a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/favourite")

	assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 500 for a wrong id", %{conn: conn} do
	user = insert(:user)

	resp =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/1/favourite")
	\|> json_response(500)

	assert resp == "Something went wrong"
	end
	end

	describe "unfavoriting" do
	test "unfavorites a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")

	assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "user timelines" do
	test "gets a users statuses", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, user_three} = User.follow(user_three, user_one)

	{:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})

	{:ok, direct_activity} =
	CommonAPI.post(user_one, %{
	"status" => "Hi, @#{user_two.nickname}.",
	"visibility" => "direct"
	})

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

	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id}] = json_response(resp, 200)
	assert id == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_two)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(direct_activity.id)
	assert id_two == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_three)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(private_activity.id)
	assert id_two == to_string(activity.id)
	end

	test "unimplemented pinned statuses feature", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_by_ap_id(note.data["actor"])

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")

	assert json_response(conn, 200) == []
	end

	test "gets an users media", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_by_ap_id(note.data["actor"])

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

	media =
	TwitterAPI.upload(file, user, "json")
	\|> Poison.decode!()

	{:ok, image_post} =
	TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)
	end

	test "gets a user's statuses without reblogs", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, _, _} = CommonAPI.repeat(post.id, user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)
	end
	end

	describe "user relationships" do
	test "returns the relationships for the current user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})

	assert [relationship] = json_response(conn, 200)

	assert to_string(other_user.id) == relationship["id"]
	end
	end

	describe "locked accounts" do
	test "/api/v1/follow_requests works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/follow_requests")

	assert [relationship] = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]
	end

	test "/api/v1/follow_requests/:id/authorize works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/authorize")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == true
	end

	test "verify_credentials", %{conn: conn} do
	user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "/api/v1/follow_requests/:id/reject works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/reject")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false
	end
	end

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

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(user.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/-1")

	assert %{"error" => "Can't find user"} = json_response(conn, 404)
	end

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

	desc = "Description of the image"

	user = insert(:user)

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

	assert media = json_response(conn, 200)

	assert media["type"] == "image"
	assert media["description"] == desc
	assert media["id"]

	object = Repo.get(Object, media["id"])
	assert object.data["actor"] == User.ap_id(user)
	end

	test "hashtag timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2hu")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)

	# works for different capitalization too
	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2HU")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)
	end)
	end

	test "multi-hashtag timeline", %{conn: conn} do
	user = insert(:user)

	{:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
	{:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
	{:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})

	any_test =
	conn
	\|> get("/api/v1/timelines/tag/test", %{"any" => ["test1"]})

	[status_none, status_test1, status_test] = json_response(any_test, 200)

	assert to_string(activity_test.id) == status_test["id"]
	assert to_string(activity_test1.id) == status_test1["id"]
	assert to_string(activity_none.id) == status_none["id"]

	restricted_test =
	conn
	\|> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})

	assert [status_test1] == json_response(restricted_test, 200)

	all_test = conn \|> get("/api/v1/timelines/tag/test", %{"all" => ["none"]})

	assert [status_none] == json_response(all_test, 200)
	end

	test "getting followers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "getting followers, hide_network", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_network: true}})
	{:ok, _user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [] == json_response(conn, 200)
	end

	test "getting followers, hide_network, same user requesting", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_network: true}})
	{:ok, _user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	refute [] == json_response(conn, 200)
	end

	test "getting following", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "getting following, hide_network", %{conn: conn} do
	user = insert(:user, %{info: %{hide_network: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [] == json_response(conn, 200)
	end

	test "getting following, hide_network, same user requesting", %{conn: conn} do
	user = insert(:user, %{info: %{hide_network: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/following")

	refute [] == json_response(conn, 200)
	end

	test "following / unfollowing a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/follow")

	assert %{"id" => _id, "following" => true} = json_response(conn, 200)

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unfollow")

	assert %{"id" => _id, "following" => false} = json_response(conn, 200)

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follows", %{"uri" => other_user.nickname})

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "blocking / unblocking a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unblock")

	assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
	end

	test "getting a list of blocks", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.block(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks")

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

	test "blocking / unblocking a domain", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	assert User.blocks?(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	refute User.blocks?(user, other_user)
	end

	test "getting a list of domain blocks", %{conn: conn} do
	user = insert(:user)

	{:ok, user} = User.block_domain(user, "bad.site")
	{:ok, user} = User.block_domain(user, "even.worse.site")

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/domain_blocks")

	domain_blocks = json_response(conn, 200)

	assert "bad.site" in domain_blocks
	assert "even.worse.site" in domain_blocks
	end

	test "unimplemented mute endpoints" do
	user = insert(:user)
	other_user = insert(:user)

	["mute", "unmute"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end)
	end

	test "unimplemented mutes, follow_requests, blocks, domain blocks" do
	user = insert(:user)

	["blocks", "domain_blocks", "mutes", "follow_requests"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/#{endpoint}")

	assert [] = json_response(conn, 200)
	end)
	end

	test "account search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	results =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "shp"})
	\|> json_response(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_two.nickname in result_ids
	assert user_three.nickname in result_ids

	results =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "2hu"})
	\|> json_response(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_three.nickname in result_ids
	end

	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

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

	{:ok, _activity} =
	CommonAPI.post(user, %{
	"status" => "This is about 2hu, but private",
	"visibility" => "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})

	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "2hu"})

	assert results = json_response(conn, 200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == []

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search fetches remote statuses", %{conn: conn} do
	capture_log(fn ->
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})

	assert results = json_response(conn, 200)

	[status] = results["statuses"]
	assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	end)
	end

	test "search doesn't show statuses that it shouldn't", %{conn: conn} do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	"status" => "This is about 2hu, but private",
	"visibility" => "private"
	})

	capture_log(fn ->
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})

	assert results = json_response(conn, 200)

	[] = results["statuses"]
	end)
	end

	test "search fetches remote accounts", %{conn: conn} do
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})

	assert results = json_response(conn, 200)
	[account] = results["accounts"]
	assert account["acct"] == "shp@social.heldscal.la"
	end

	test "returns the favorites of a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})

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

	first_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites")

	assert [status] = json_response(first_conn, 200)
	assert status["id"] == to_string(activity.id)

	assert [{"link", _link_header}] =
	Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)

	# Honours query params
	{:ok, second_activity} =
	CommonAPI.post(other_user, %{
	"status" =>
	"Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
	})

	{:ok, _, _} = CommonAPI.favorite(second_activity.id, user)

	last_like = status["id"]

	second_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites?since_id=#{last_like}")

	assert [second_status] = json_response(second_conn, 200)
	assert second_status["id"] == to_string(second_activity.id)

	third_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites?limit=0")

	assert [] = json_response(third_conn, 200)
	end

	describe "updating credentials" do
	test "updates the user's bio", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"note" => "I drink #cofe with @#{user2.nickname}"
	})

	assert user = json_response(conn, 200)

	assert user["note"] ==
	"I drink <a class=\"hashtag\" data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span class=\"h-card\"><a data-user=\"#{
	user2.id
	}\" class=\"u-url mention\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
	end

	test "updates the user's locking status", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{locked: "true"})

	assert user = json_response(conn, 200)
	assert user["locked"] == true
	end

	test "updates the user's name", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})

	assert user = json_response(conn, 200)
	assert user["display_name"] == "markorepairs"
	end

	test "updates the user's avatar", %{conn: conn} do
	user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})

	assert user_response = json_response(conn, 200)
	assert user_response["avatar"] != User.avatar_url(user)
	end

	test "updates the user's banner", %{conn: conn} do
	user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})

	assert user_response = json_response(conn, 200)
	assert user_response["header"] != User.banner_url(user)
	end
	end

	test "get instance information", %{conn: conn} do
	user = insert(:user, %{local: true})

	user2 = insert(:user, %{local: true})
	{:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)

	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	{:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	# Stats should count users with missing or nil `info.deactivated` value
	user = Repo.get(User, user.id)
	info_change = Changeset.change(user.info, %{deactivated: nil})

	{:ok, _user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> User.update_and_set_cache()

	Pleroma.Stats.update_stats()

	conn = get(conn, "/api/v1/instance")

	assert result = json_response(conn, 200)

	stats = result["stats"]

	assert stats
	assert stats["user_count"] == 1
	assert stats["status_count"] == 1
	assert stats["domain_count"] == 2
	end

	test "get peers", %{conn: conn} do
	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	Pleroma.Stats.update_stats()

	conn = get(conn, "/api/v1/instance/peers")

	assert result = json_response(conn, 200)

	assert ["peer1.com", "peer2.com"] == Enum.sort(result)
	end

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

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})

	assert _result = json_response(conn, 200)

	user = User.get_cached_by_ap_id(user.ap_id)
	assert user.info.settings == %{"programming" => "socks"}
	end

	describe "pinned statuses" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)

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

	[user: user, activity: activity]
	end

	test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)

	id_str = to_string(activity.id)

	assert [%{"id" => ^id_str, "pinned" => true}] = result
	end

	test "pin status", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "pinned" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response(200)

	assert [%{"id" => ^id_str, "pinned" => true}] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)
	end

	test "unpin status", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)

	id_str = to_string(activity.id)
	user = refresh_record(user)

	assert %{"id" => ^id_str, "pinned" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unpin")
	\|> json_response(200)

	assert [] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)
	end

	test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})

	id_str_one = to_string(activity_one.id)

	assert %{"id" => ^id_str_one, "pinned" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{id_str_one}/pin")
	\|> json_response(200)

	user = refresh_record(user)

	assert %{"error" => "You have already pinned the maximum number of statuses"} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity_two.id}/pin")
	\|> json_response(400)
	end

	test "Status rich-media Card", %{conn: conn, user: user} do
	{:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp"})

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response(200)

	assert response == %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"provider_name" => "www.imdb.com",
	+ "provider_url" => "http://www.imdb.com",
	"title" => "The Rock",
	"type" => "link",
	- "url" => "http://www.imdb.com/title/tt0117500/"
	+ "url" => "http://www.imdb.com/title/tt0117500/",
	+ "description" => nil,
	+ "pleroma" => %{
	+ "opengraph" => %{
	+ "image" => "http://ia.media-imdb.com/images/rock.jpg",
	+ "title" => "The Rock",
	+ "type" => "video.movie",
	+ "url" => "http://www.imdb.com/title/tt0117500/"
	+ }
	+ }
	}
	end
	end
	end
	diff --git a/test/web/mastodon_api/status_view_test.exs b/test/web/mastodon_api/status_view_test.exs
	index ebf6273e8..f957fedac 100644
	--- a/test/web/mastodon_api/status_view_test.exs
	+++ b/test/web/mastodon_api/status_view_test.exs
	@@ -1,236 +1,237 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
	use Pleroma.DataCase

	alias Pleroma.Web.MastodonAPI.{StatusView, AccountView}
	alias Pleroma.User
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Activity
	import Pleroma.Factory
	import Tesla.Mock

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

	test "returns a temporary ap_id based user for activities missing db users" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	Repo.delete(user)
	Cachex.clear(:user_cache)

	%{account: ms_user} = StatusView.render("status.json", activity: activity)

	assert ms_user.acct == "erroruser@example.com"
	end

	test "tries to get a user by nickname if fetching by ap_id doesn't work" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
	\|> Repo.update()

	Cachex.clear(:user_cache)

	result = StatusView.render("status.json", activity: activity)

	assert result[:account][:id] == to_string(user.id)
	end

	test "a note with null content" do
	note = insert(:note_activity)

	data =
	note.data
	\|> put_in(["object", "content"], nil)

	note =
	note
	\|> Map.put(:data, data)

	User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("status.json", %{activity: note})

	assert status.content == ""
	end

	test "a note activity" do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("status.json", %{activity: note})

	created_at =
	(note.data["object"]["published"] \|\| "")
	\|> String.replace(~r/\.\d+Z/, ".000Z")

	expected = %{
	id: to_string(note.id),
	uri: note.data["object"]["id"],
	url: note.data["object"]["id"],
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	+ card: nil,
	reblog: nil,
	content: HtmlSanitizeEx.basic_html(note.data["object"]["content"]),
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	favourited: false,
	muted: false,
	pinned: false,
	sensitive: false,
	spoiler_text: note.data["object"]["summary"],
	visibility: "public",
	media_attachments: [],
	mentions: [],
	tags: [
	%{
	name: "#{note.data["object"]["tag"]}",
	url: "/tag/#{note.data["object"]["tag"]}"
	}
	],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: [
	%{
	shortcode: "2hu",
	url: "corndog.png",
	static_url: "corndog.png",
	visible_in_picker: false
	}
	]
	}

	assert status == expected
	end

	test "a reply" do
	note = insert(:note_activity)
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "he", "in_reply_to_status_id" => note.id})

	status = StatusView.render("status.json", %{activity: activity})

	assert status.in_reply_to_id == to_string(note.id)

	[status] = StatusView.render("index.json", %{activities: [activity], as: :activity})

	assert status.in_reply_to_id == to_string(note.id)
	end

	test "contains mentions" do
	incoming = File.read!("test/fixtures/incoming_reply_mastodon.xml")
	# a user with this ap id might be in the cache.
	recipient = "https://pleroma.soykaf.com/users/lain"
	user = insert(:user, %{ap_id: recipient})

	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	status = StatusView.render("status.json", %{activity: activity})

	actor = Repo.get_by(User, ap_id: activity.actor)

	assert status.mentions ==
	Enum.map([user, actor], fn u -> AccountView.render("mention.json", %{user: u}) end)
	end

	test "attachments" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl"
	}
	],
	"uuid" => 6
	}

	expected = %{
	id: "1638338801",
	type: "image",
	url: "someurl",
	remote_url: "someurl",
	preview_url: "someurl",
	text_url: "someurl",
	description: nil
	}

	assert expected == StatusView.render("attachment.json", %{attachment: object})

	# If theres a "id", use that instead of the generated one
	object = Map.put(object, "id", 2)
	assert %{id: "2"} = StatusView.render("attachment.json", %{attachment: object})
	end

	test "a reblog" do
	user = insert(:user)
	activity = insert(:note_activity)

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

	represented = StatusView.render("status.json", %{for: user, activity: reblog})

	assert represented[:id] == to_string(reblog.id)
	assert represented[:reblog][:id] == to_string(activity.id)
	assert represented[:emojis] == []
	end

	test "a peertube video" do
	user = insert(:user)

	{:ok, object} =
	ActivityPub.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("status.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	end

	describe "build_tags/1" do
	test "it returns a a dictionary tags" do
	object_tags = [
	"fediverse",
	"mastodon",
	"nextcloud",
	%{
	"href" => "https://kawen.space/users/lain",
	"name" => "@lain@kawen.space",
	"type" => "Mention"
	}
	]

	assert StatusView.build_tags(object_tags) == [
	%{name: "fediverse", url: "/tag/fediverse"},
	%{name: "mastodon", url: "/tag/mastodon"},
	%{name: "nextcloud", url: "/tag/nextcloud"}
	]
	end
	end
	end
	diff --git a/test/web/rich_media/controllers/rich_media_controller_test.exs b/test/web/rich_media/controllers/rich_media_controller_test.exs
	deleted file mode 100644
	index fef126513..000000000
	--- a/test/web/rich_media/controllers/rich_media_controller_test.exs
	+++ /dev/null
	@@ -1,49 +0,0 @@
	-# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	-# SPDX-License-Identifier: AGPL-3.0-only
	-
	-defmodule Pleroma.Web.RichMedia.RichMediaControllerTest do
	- use Pleroma.Web.ConnCase
	- import Pleroma.Factory
	- import Tesla.Mock
	-
	- setup do
	- mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	- :ok
	- end
	-
	- describe "GET /api/rich_media/parse" do
	- setup do
	- user = insert(:user)
	-
	- [user: user]
	- end
	-
	- test "returns 404 if not metadata found", %{user: user} do
	- build_conn()
	- \|> with_credentials(user.nickname, "test")
	- \|> get("/api/rich_media/parse", %{"url" => "http://example.com/empty"})
	- \|> json_response(404)
	- end
	-
	- test "returns OGP metadata", %{user: user} do
	- response =
	- build_conn()
	- \|> with_credentials(user.nickname, "test")
	- \|> get("/api/rich_media/parse", %{"url" => "http://example.com/ogp"})
	- \|> json_response(200)
	-
	- assert response == %{
	- "image" => "http://ia.media-imdb.com/images/rock.jpg",
	- "title" => "The Rock",
	- "type" => "video.movie",
	- "url" => "http://www.imdb.com/title/tt0117500/"
	- }
	- end
	- end
	-
	- defp with_credentials(conn, username, password) do
	- header_content = "Basic " <> Base.encode64("#{username}:#{password}")
	- put_req_header(conn, "authorization", header_content)
	- end
	-end
	diff --git a/test/web/rich_media/parser_test.exs b/test/web/rich_media/parser_test.exs
	index e14b5061a..93a58c528 100644
	--- a/test/web/rich_media/parser_test.exs
	+++ b/test/web/rich_media/parser_test.exs
	@@ -1,92 +1,91 @@
	defmodule Pleroma.Web.RichMedia.ParserTest do
	use ExUnit.Case, async: true

	setup do
	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "http://example.com/ogp"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/ogp.html")}

	%{
	method: :get,
	url: "http://example.com/twitter-card"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/twitter_card.html")}

	%{
	method: :get,
	url: "http://example.com/oembed"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/oembed.html")}

	%{
	method: :get,
	url: "http://example.com/oembed.json"
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/oembed.json")}

	%{method: :get, url: "http://example.com/empty"} ->
	%Tesla.Env{status: 200, body: "hello"}
	end)

	:ok
	end

	test "returns error when no metadata present" do
	assert {:error, _} = Pleroma.Web.RichMedia.Parser.parse("http://example.com/empty")
	end

	test "parses ogp" do
	assert Pleroma.Web.RichMedia.Parser.parse("http://example.com/ogp") ==
	{:ok,
	%{
	image: "http://ia.media-imdb.com/images/rock.jpg",
	title: "The Rock",
	type: "video.movie",
	url: "http://www.imdb.com/title/tt0117500/"
	}}
	end

	test "parses twitter card" do
	assert Pleroma.Web.RichMedia.Parser.parse("http://example.com/twitter-card") ==
	{:ok,
	%{
	card: "summary",
	site: "@flickr",
	image: "https://farm6.staticflickr.com/5510/14338202952_93595258ff_z.jpg",
	title: "Small Island Developing States Photo Submission",
	description: "View the album on Flickr."
	}}
	end

	test "parses OEmbed" do
	assert Pleroma.Web.RichMedia.Parser.parse("http://example.com/oembed") ==
	{:ok,
	%{
	- "author_name" => "‮‭‬bees‬",
	- "author_url" => "https://www.flickr.com/photos/bees/",
	- "cache_age" => 3600,
	- "flickr_type" => "photo",
	- "height" => "768",
	- "html" =>
	+ author_name: "‮‭‬bees‬",
	+ author_url: "https://www.flickr.com/photos/bees/",
	+ cache_age: 3600,
	+ flickr_type: "photo",
	+ height: "768",
	+ html:
	"<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/bees/2362225867/\" title=\"Bacon Lollys by ‮‭‬bees‬, on Flickr\"><img src=\"https://farm4.staticflickr.com/3040/2362225867_4a87ab8baf_b.jpg\" width=\"1024\" height=\"768\" alt=\"Bacon Lollys\"></a><script async src=\"https://embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>",
	- "license" => "All Rights Reserved",
	- "license_id" => 0,
	- "provider_name" => "Flickr",
	- "provider_url" => "https://www.flickr.com/",
	- "thumbnail_height" => 150,
	- "thumbnail_url" =>
	- "https://farm4.staticflickr.com/3040/2362225867_4a87ab8baf_q.jpg",
	- "thumbnail_width" => 150,
	- "title" => "Bacon Lollys",
	- "type" => "photo",
	- "url" => "https://farm4.staticflickr.com/3040/2362225867_4a87ab8baf_b.jpg",
	- "version" => "1.0",
	- "web_page" => "https://www.flickr.com/photos/bees/2362225867/",
	- "web_page_short_url" => "https://flic.kr/p/4AK2sc",
	- "width" => "1024"
	+ license: "All Rights Reserved",
	+ license_id: 0,
	+ provider_name: "Flickr",
	+ provider_url: "https://www.flickr.com/",
	+ thumbnail_height: 150,
	+ thumbnail_url: "https://farm4.staticflickr.com/3040/2362225867_4a87ab8baf_q.jpg",
	+ thumbnail_width: 150,
	+ title: "Bacon Lollys",
	+ type: "photo",
	+ url: "https://farm4.staticflickr.com/3040/2362225867_4a87ab8baf_b.jpg",
	+ version: "1.0",
	+ web_page: "https://www.flickr.com/photos/bees/2362225867/",
	+ web_page_short_url: "https://flic.kr/p/4AK2sc",
	+ width: "1024"
	}}
	end
	end
	diff --git a/test/web/twitter_api/representers/activity_representer_test.exs b/test/web/twitter_api/representers/activity_representer_test.exs
	index ef0294140..ea5813733 100644
	--- a/test/web/twitter_api/representers/activity_representer_test.exs
	+++ b/test/web/twitter_api/representers/activity_representer_test.exs
	@@ -1,203 +1,204 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenterTest do
	use Pleroma.DataCase
	alias Pleroma.{User, Activity, Object}
	alias Pleroma.Web.TwitterAPI.Representers.{ActivityRepresenter, ObjectRepresenter}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.UserView
	import Pleroma.Factory

	test "an announce activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	activity_actor = Repo.get_by(User, ap_id: note_activity.data["actor"])
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, announce_activity, _object} = ActivityPub.announce(user, object)
	note_activity = Activity.get_by_ap_id(note_activity.data["id"])

	status =
	ActivityRepresenter.to_map(announce_activity, %{
	users: [user, activity_actor],
	announced_activity: note_activity,
	for: user
	})

	assert status["id"] == announce_activity.id
	assert status["user"] == UserView.render("show.json", %{user: user, for: user})

	retweeted_status =
	ActivityRepresenter.to_map(note_activity, %{user: activity_actor, for: user})

	assert retweeted_status["repeated"] == true
	assert retweeted_status["id"] == note_activity.id
	assert status["statusnet_conversation_id"] == retweeted_status["statusnet_conversation_id"]

	assert status["retweeted_status"] == retweeted_status
	assert status["activity_type"] == "repeat"
	end

	test "a like activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, like_activity, _object} = ActivityPub.like(user, object)

	status =
	ActivityRepresenter.to_map(like_activity, %{user: user, liked_activity: note_activity})

	assert status["id"] == like_activity.id
	assert status["in_reply_to_status_id"] == note_activity.id

	note_activity = Activity.get_by_ap_id(note_activity.data["id"])
	activity_actor = Repo.get_by(User, ap_id: note_activity.data["actor"])
	liked_status = ActivityRepresenter.to_map(note_activity, %{user: activity_actor, for: user})
	assert liked_status["favorited"] == true
	assert status["activity_type"] == "like"
	end

	test "an activity" do
	user = insert(:user)
	# {:ok, mentioned_user } = UserBuilder.insert(%{nickname: "shp", ap_id: "shp"})
	mentioned_user = insert(:user, %{nickname: "shp"})

	# {:ok, follower} = UserBuilder.insert(%{following: [User.ap_followers(user)]})
	follower = insert(:user, %{following: [User.ap_followers(user)]})

	object = %Object{
	data: %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}
	}

	content_html =
	"<script>alert('YAY')</script>Some :2hu: content mentioning <a href='#{mentioned_user.ap_id}'>@shp</shp>"

	content = HtmlSanitizeEx.strip_tags(content_html)
	date = DateTime.from_naive!(~N[2016-05-24 13:26:08.003], "Etc/UTC") \|> DateTime.to_iso8601()

	{:ok, convo_object} = Object.context_mapping("2hu") \|> Repo.insert()

	to = [
	User.ap_followers(user),
	"https://www.w3.org/ns/activitystreams#Public",
	mentioned_user.ap_id
	]

	activity = %Activity{
	id: 1,
	data: %{
	"type" => "Create",
	"id" => "id",
	"to" => to,
	"actor" => User.ap_id(user),
	"object" => %{
	"published" => date,
	"type" => "Note",
	"content" => content_html,
	"summary" => "2hu :2hu:",
	"inReplyToStatusId" => 213_123,
	"attachment" => [
	object
	],
	"external_url" => "some url",
	"like_count" => 5,
	"announcement_count" => 3,
	"context" => "2hu",
	"tag" => ["content", "mentioning", "nsfw"],
	"emoji" => %{
	"2hu" => "corndog.png"
	}
	},
	"published" => date,
	"context" => "2hu"
	},
	local: false,
	recipients: to
	}

	expected_html =
	"<p>2hu <img height=\"32px\" width=\"32px\" alt=\"2hu\" title=\"2hu\" src=\"corndog.png\" /></p>alert('YAY')Some <img height=\"32px\" width=\"32px\" alt=\"2hu\" title=\"2hu\" src=\"corndog.png\" /> content mentioning <a href=\"#{
	mentioned_user.ap_id
	}\">@shp</a>"

	expected_status = %{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: follower}),
	"is_local" => false,
	"statusnet_html" => expected_html,
	"text" => "2hu :2hu:" <> content,
	"is_post_verb" => true,
	"created_at" => "Tue May 24 13:26:08 +0000 2016",
	"in_reply_to_status_id" => 213_123,
	"in_reply_to_screen_name" => nil,
	"in_reply_to_user_id" => nil,
	"in_reply_to_profileurl" => nil,
	"in_reply_to_ostatus_uri" => nil,
	"statusnet_conversation_id" => convo_object.id,
	"attachments" => [
	ObjectRepresenter.to_map(object)
	],
	"attentions" => [
	UserView.render("show.json", %{user: mentioned_user, for: follower})
	],
	"fave_num" => 5,
	"repeat_num" => 3,
	"favorited" => false,
	"repeated" => false,
	"pinned" => false,
	"external_url" => "some url",
	"tags" => ["nsfw", "content", "mentioning"],
	"activity_type" => "post",
	"possibly_sensitive" => true,
	"uri" => activity.data["object"]["id"],
	"visibility" => "direct",
	+ "card" => nil,
	"summary" => "2hu :2hu:",
	"summary_html" =>
	"2hu <img height=\"32px\" width=\"32px\" alt=\"2hu\" title=\"2hu\" src=\"corndog.png\" />"
	}

	assert ActivityRepresenter.to_map(activity, %{
	user: user,
	for: follower,
	mentioned: [mentioned_user]
	}) == expected_status
	end

	test "an undo for a follow" do
	follower = insert(:user)
	followed = insert(:user)

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

	map = ActivityRepresenter.to_map(unfollow, %{user: follower})
	assert map["is_post_verb"] == false
	assert map["activity_type"] == "undo"
	end

	test "a delete activity" do
	object = insert(:note)
	user = User.get_by_ap_id(object.data["actor"])

	{:ok, delete} = ActivityPub.delete(object)

	map = ActivityRepresenter.to_map(delete, %{user: user})

	assert map["is_post_verb"] == false
	assert map["activity_type"] == "delete"
	assert map["uri"] == object.data["id"]
	end
	end
	diff --git a/test/web/twitter_api/views/activity_view_test.exs b/test/web/twitter_api/views/activity_view_test.exs
	index ba053d20d..4f854ecaa 100644
	--- a/test/web/twitter_api/views/activity_view_test.exs
	+++ b/test/web/twitter_api/views/activity_view_test.exs
	@@ -1,354 +1,355 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.ActivityViewTest do
	use Pleroma.DataCase

	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Repo
	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Pleroma.Factory
	import Tesla.Mock

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

	import Mock

	test "returns a temporary ap_id based user for activities missing db users" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	Repo.delete(user)
	Cachex.clear(:user_cache)

	%{"user" => tw_user} = ActivityView.render("activity.json", activity: activity)

	assert tw_user["screen_name"] == "erroruser@example.com"
	assert tw_user["name"] == user.ap_id
	assert tw_user["statusnet_profile_url"] == user.ap_id
	end

	test "tries to get a user by nickname if fetching by ap_id doesn't work" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
	\|> Repo.update()

	Cachex.clear(:user_cache)

	result = ActivityView.render("activity.json", activity: activity)
	assert result["user"]["id"] == user.id
	end

	test "a create activity with a html status" do
	text = """
	#Bike log - Commute Tuesday\nhttps://pla.bike/posts/20181211/\n#cycling #CHScycling #commute\nMVIMG_20181211_054020.jpg
	"""

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

	result = ActivityView.render("activity.json", activity: activity)

	assert result["statusnet_html"] ==
	"<a class=\"hashtag\" data-tag=\"bike\" href=\"http://localhost:4001/tag/bike\">#Bike</a> log - Commute Tuesday<br /><a href=\"https://pla.bike/posts/20181211/\">https://pla.bike/posts/20181211/</a><br /><a class=\"hashtag\" data-tag=\"cycling\" href=\"http://localhost:4001/tag/cycling\">#cycling</a> <a class=\"hashtag\" data-tag=\"chscycling\" href=\"http://localhost:4001/tag/chscycling\">#CHScycling</a> <a class=\"hashtag\" data-tag=\"commute\" href=\"http://localhost:4001/tag/commute\">#commute</a><br />MVIMG_20181211_054020.jpg"

	assert result["text"] ==
	"#Bike log - Commute Tuesday\nhttps://pla.bike/posts/20181211/\n#cycling #CHScycling #commute\nMVIMG_20181211_054020.jpg"
	end

	test "a create activity with a summary containing emoji" do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	"spoiler_text" => ":woollysocks: meow",
	"status" => "."
	})

	result = ActivityView.render("activity.json", activity: activity)

	expected = ":woollysocks: meow"

	expected_html =
	"<img height=\"32px\" width=\"32px\" alt=\"woollysocks\" title=\"woollysocks\" src=\"http://localhost:4001/finmoji/128px/woollysocks-128.png\" /> meow"

	assert result["summary"] == expected
	assert result["summary_html"] == expected_html
	end

	test "a create activity with a summary containing invalid HTML" do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	"spoiler_text" => "<span style=\"color: magenta; font-size: 32px;\">meow</span>",
	"status" => "."
	})

	result = ActivityView.render("activity.json", activity: activity)

	expected = "meow"

	assert result["summary"] == expected
	assert result["summary_html"] == expected
	end

	test "a create activity with a note" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	result = ActivityView.render("activity.json", activity: activity)

	convo_id = TwitterAPI.context_to_conversation_id(activity.data["object"]["context"])

	expected = %{
	"activity_type" => "post",
	"attachments" => [],
	"attentions" => [
	UserView.render("show.json", %{user: other_user})
	],
	"created_at" => activity.data["object"]["published"] \|> Utils.date_to_asctime(),
	"external_url" => activity.data["object"]["id"],
	"fave_num" => 0,
	"favorited" => false,
	"id" => activity.id,
	"in_reply_to_status_id" => nil,
	"in_reply_to_screen_name" => nil,
	"in_reply_to_user_id" => nil,
	"in_reply_to_profileurl" => nil,
	"in_reply_to_ostatus_uri" => nil,
	"is_local" => true,
	"is_post_verb" => true,
	"possibly_sensitive" => false,
	"repeat_num" => 0,
	"repeated" => false,
	"pinned" => false,
	"statusnet_conversation_id" => convo_id,
	"summary" => "",
	"summary_html" => "",
	"statusnet_html" =>
	"Hey <span class=\"h-card\"><a data-user=\"#{other_user.id}\" class=\"u-url mention\" href=\"#{
	other_user.ap_id
	}\">@<span>shp</span></a></span>!",
	"tags" => [],
	"text" => "Hey @shp!",
	"uri" => activity.data["object"]["id"],
	"user" => UserView.render("show.json", %{user: user}),
	- "visibility" => "direct"
	+ "visibility" => "direct",
	+ "card" => nil
	}

	assert result == expected
	end

	test "a list of activities" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})
	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})

	convo_id = TwitterAPI.context_to_conversation_id(activity.data["object"]["context"])

	mocks = [
	{
	TwitterAPI,
	[],
	[context_to_conversation_id: fn _ -> false end]
	},
	{
	User,
	[:passthrough],
	[get_cached_by_ap_id: fn _ -> nil end]
	}
	]

	with_mocks mocks do
	[result] = ActivityView.render("index.json", activities: [activity])

	assert result["statusnet_conversation_id"] == convo_id
	assert result["user"]
	refute called(TwitterAPI.context_to_conversation_id(:_))
	refute called(User.get_cached_by_ap_id(user.ap_id))
	refute called(User.get_cached_by_ap_id(other_user.ap_id))
	end
	end

	test "an activity that is a reply" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})

	{:ok, answer} =
	CommonAPI.post(other_user, %{"status" => "Hi!", "in_reply_to_status_id" => activity.id})

	result = ActivityView.render("activity.json", %{activity: answer})

	assert result["in_reply_to_status_id"] == activity.id
	end

	test "a like activity" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	{:ok, like, _object} = CommonAPI.favorite(activity.id, other_user)

	result = ActivityView.render("activity.json", activity: like)
	activity = Pleroma.Activity.get_by_ap_id(activity.data["id"])

	expected = %{
	"activity_type" => "like",
	"created_at" => like.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => like.data["id"],
	"id" => like.id,
	"in_reply_to_status_id" => activity.id,
	"is_local" => true,
	"is_post_verb" => false,
	"favorited_status" => ActivityView.render("activity.json", activity: activity),
	"statusnet_html" => "shp favorited a status.",
	"text" => "shp favorited a status.",
	"uri" => "tag:#{like.data["id"]}:objectType=Favourite",
	"user" => UserView.render("show.json", user: other_user)
	}

	assert result == expected
	end

	test "a like activity for deleted post" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	{:ok, like, _object} = CommonAPI.favorite(activity.id, other_user)
	CommonAPI.delete(activity.id, user)

	result = ActivityView.render("activity.json", activity: like)

	expected = %{
	"activity_type" => "like",
	"created_at" => like.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => like.data["id"],
	"id" => like.id,
	"in_reply_to_status_id" => nil,
	"is_local" => true,
	"is_post_verb" => false,
	"favorited_status" => nil,
	"statusnet_html" => "shp favorited a status.",
	"text" => "shp favorited a status.",
	"uri" => "tag:#{like.data["id"]}:objectType=Favourite",
	"user" => UserView.render("show.json", user: other_user)
	}

	assert result == expected
	end

	test "an announce activity" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	{:ok, announce, _object} = CommonAPI.repeat(activity.id, other_user)

	convo_id = TwitterAPI.context_to_conversation_id(activity.data["object"]["context"])

	activity = Repo.get(Activity, activity.id)

	result = ActivityView.render("activity.json", activity: announce)

	expected = %{
	"activity_type" => "repeat",
	"created_at" => announce.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => announce.data["id"],
	"id" => announce.id,
	"is_local" => true,
	"is_post_verb" => false,
	"statusnet_html" => "shp retweeted a status.",
	"text" => "shp retweeted a status.",
	"uri" => "tag:#{announce.data["id"]}:objectType=note",
	"user" => UserView.render("show.json", user: other_user),
	"retweeted_status" => ActivityView.render("activity.json", activity: activity),
	"statusnet_conversation_id" => convo_id
	}

	assert result == expected
	end

	test "A follow activity" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, follower} = User.follow(user, other_user)
	{:ok, follow} = ActivityPub.follow(follower, other_user)

	result = ActivityView.render("activity.json", activity: follow)

	expected = %{
	"activity_type" => "follow",
	"attentions" => [],
	"created_at" => follow.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => follow.data["id"],
	"id" => follow.id,
	"in_reply_to_status_id" => nil,
	"is_local" => true,
	"is_post_verb" => false,
	"statusnet_html" => "#{user.nickname} started following shp",
	"text" => "#{user.nickname} started following shp",
	"user" => UserView.render("show.json", user: user)
	}

	assert result == expected
	end

	test "a delete activity" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	{:ok, delete} = CommonAPI.delete(activity.id, user)

	result = ActivityView.render("activity.json", activity: delete)

	expected = %{
	"activity_type" => "delete",
	"attentions" => [],
	"created_at" => delete.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => delete.data["id"],
	"id" => delete.id,
	"in_reply_to_status_id" => nil,
	"is_local" => true,
	"is_post_verb" => false,
	"statusnet_html" => "deleted notice {{tag",
	"text" => "deleted notice {{tag",
	"uri" => delete.data["object"],
	"user" => UserView.render("show.json", user: user)
	}

	assert result == expected
	end

	test "a peertube video" do
	{:ok, object} =
	ActivityPub.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	result = ActivityView.render("activity.json", activity: activity)

	assert length(result["attachments"]) == 1
	assert result["summary"] == "Friday Night"
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 12:23 PM (1 d, 37 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798095
Default Alt Text: (216 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions