No OneTemporary
Actions

Authored By

Unknown

Size

221 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 24b4f045a..8485a8009 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,596 +1,618 @@
	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)

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

	def get_recipients(data) do
	(data["to"] \|\| []) ++ (data["cc"] \|\| [])
	end

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

	def insert(map, local \\ true) when is_map(map) do
	with nil <- Activity.get_by_ap_id(map["id"]),
	map <- lazy_put_activity_defaults(map),
	:ok <- check_actor_is_active(map["actor"]),
	{:ok, map} <- MRF.filter(map),
	:ok <- insert_full_object(map) do
	{:ok, activity} =
	Repo.insert(%Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: get_recipients(map)
	})

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

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

	if Enum.member?(activity.data["to"], "https://www.w3.org/ns/activitystreams#Public") do
	Pleroma.Web.Streamer.stream("public", activity)

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

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

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

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

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

	def 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
	) do
	with true <- is_public?(object),
	announce_data <- make_announce_data(user, object, activity_id),
	{: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, announce_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, local \\ true) do
	+ def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
	with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
	- unfollow_data <- make_unfollow_data(follower, followed, follow_activity),
	+ unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
	{:ok, activity} <- insert(unfollow_data, local),
	- :ok,
	- maybe_federate(activity) do
	+ :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 Repo.delete(object),
	Repo.delete_all(Activity.all_non_create_by_object_ap_id_q(id)),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity),
	{:ok, _actor} <- User.decrease_note_count(user) do
	{:ok, activity}
	end
	end

	+ def block(blocker, blocked, activity_id \\ nil, local \\ true) do
	+ follow_activity = fetch_latest_follow(blocker, blocked)
	+
	+ if follow_activity do
	+ unfollow(blocker, blocked, nil, local)
	+ end
	+
	+ with block_data <- make_block_data(blocker, blocked, activity_id),
	+ {:ok, activity} <- insert(block_data, local),
	+ :ok <- maybe_federate(activity) do
	+ {:ok, activity}
	+ 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

	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)

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

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

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

	defp restrict_since(query, _), do: query

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

	defp restrict_tag(query, _), do: query

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

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

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

	defp restrict_limit(query, %{"limit" => limit}) do
	from(activity in query, limit: ^limit)
	end

	defp restrict_limit(query, _), do: query

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

	defp restrict_local(query, _), do: query

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

	defp restrict_max(query, _), do: query

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

	defp restrict_actor(query, _), do: query

	defp restrict_type(query, %{"type" => type}) when is_binary(type) do
	restrict_type(query, %{"type" => [type]})
	end

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

	defp restrict_type(query, _), do: query

	defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
	from(
	activity in query,
	where: fragment("? <@ (? #> '{\"object\",\"likes\"}')", ^ap_id, activity.data)
	)
	end

	defp restrict_favorited_by(query, _), do: query

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

	defp restrict_media(query, _), do: query

	# Only search through last 100_000 activities by default
	defp restrict_recent(query, %{"whole_db" => true}), do: query

	defp restrict_recent(query, _) do
	since = (Repo.aggregate(Activity, :max, :id) \|\| 0) - 100_000

	from(activity in query, where: activity.id > ^since)
	end

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

	from(
	activity in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
	where: fragment("not (?->'to' \\?\| ?)", activity.data, ^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

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

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

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

	def upload(file) do
	data = Upload.store(file)
	Repo.insert(%Object{data: data})
	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"]}]
	}

	data = Transmogrifier.maybe_fix_user_object(data)

	user_data = %{
	ap_id: data["id"],
	info: %{
	"ap_enabled" => true,
	"source_data" => data,
	"banner" => banner
	},
	avatar: avatar,
	nickname: "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}",
	name: data["name"],
	follower_address: data["followers"],
	bio: data["summary"]
	}

	{:ok, user_data}
	end

	def fetch_and_prepare_user_from_ap_id(ap_id) do
	with {:ok, %{status_code: 200, body: body}} <-
	@httpoison.get(ap_id, Accept: "application/activity+json"),
	{:ok, data} <- Jason.decode(body) 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 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

	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}} ->
	(data["endpoints"] && data["endpoints"]["sharedInbox"]) \|\| data["inbox"]
	end)
	\|> Enum.uniq()

	{: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

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

	@httpoison.post(
	inbox,
	json,
	[{"Content-Type", "application/activity+json"}, {"signature", signature}],
	hackney: [pool: :default]
	)
	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 true <- String.starts_with?(id, "http"),
	{:ok, %{body: body, status_code: code}} when code in 200..299 <-
	@httpoison.get(
	id,
	[Accept: "application/activity+json"],
	follow_redirect: true,
	timeout: 10000,
	recv_timeout: 20000
	),
	{:ok, data} <- Jason.decode(body),
	nil <- Object.get_by_ap_id(data["id"]),
	params <- %{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => data["attributedTo"],
	"object" => data
	},
	{:ok, activity} <- Transmogrifier.handle_incoming(params) do
	{:ok, Object.get_by_ap_id(activity.data["object"]["id"])}
	else
	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.get_by_ap_id(activity.data["object"]["id"])}
	e -> e
	end
	end
	end
	end

	def is_public?(activity) do
	"https://www.w3.org/ns/activitystreams#Public" in (activity.data["to"] ++
	(activity.data["cc"] \|\| []))
	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
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index 7d6fd8632..803445011 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,529 +1,578 @@
	defmodule Pleroma.Web.ActivityPub.Transmogrifier do
	@moduledoc """
	A module to handle coding from internal to wire ActivityPub and back.
	"""
	alias Pleroma.User
	alias Pleroma.Object
	alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Ecto.Query

	require Logger

	@doc """
	Modifies an incoming AP object (mastodon format) to our internal format.
	"""
	def fix_object(object) do
	object
	\|> Map.put("actor", object["attributedTo"])
	\|> fix_attachments
	\|> fix_context
	\|> fix_in_reply_to
	\|> fix_emoji
	\|> fix_tag
	end

	def fix_in_reply_to(%{"inReplyTo" => in_reply_to_id} = object)
	when not is_nil(in_reply_to_id) do
	case ActivityPub.fetch_object_from_id(in_reply_to_id) do
	{:ok, replied_object} ->
	activity = Activity.get_create_activity_by_object_ap_id(replied_object.data["id"])

	object
	\|> Map.put("inReplyTo", replied_object.data["id"])
	\|> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] \|\| in_reply_to_id)
	\|> Map.put("inReplyToStatusId", activity.id)
	\|> Map.put("conversation", replied_object.data["context"] \|\| object["conversation"])
	\|> Map.put("context", replied_object.data["context"] \|\| object["conversation"])

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

	def fix_in_reply_to(object), do: object

	def fix_context(object) do
	object
	\|> Map.put("context", object["conversation"])
	end

	def fix_attachments(object) do
	attachments =
	(object["attachment"] \|\| [])
	\|> Enum.map(fn data ->
	url = [%{"type" => "Link", "mediaType" => data["mediaType"], "href" => data["url"]}]
	Map.put(data, "url", url)
	end)

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

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

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

	name =
	if String.starts_with?(name, ":") do
	name \|> String.slice(1..-2)
	else
	name
	end

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

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

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

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

	combined = (object["tag"] \|\| []) ++ tags

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

	# TODO: validate those with a Ecto scheme
	# - tags
	# - emoji
	def handle_incoming(%{"type" => "Create", "object" => %{"type" => "Note"} = object} = data) do
	with nil <- Activity.get_create_activity_by_object_ap_id(object["id"]),
	%User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
	object = fix_object(data["object"])

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

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

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

	User.follow(follower, followed)
	{:ok, activity}
	else
	_e -> :error
	end
	end

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

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

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

	banner = new_user_data[:info]["banner"]

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

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

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

	# TODO: Make secure.
	def handle_incoming(
	%{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => _id} = _data
	) do
	object_id =
	case object_id do
	%{"id" => id} -> id
	id -> id
	end

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

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

	+ def handle_incoming(
	+ %{
	+ "type" => "Undo",
	+ "object" => %{"type" => "Follow", "object" => followed},
	+ "actor" => follower,
	+ "id" => id
	+ } = _data
	+ ) do
	+ with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	+ %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
	+ {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
	+ User.unfollow(follower, followed)
	+ {:ok, activity}
	+ else
	+ e -> :error
	+ end
	+ end
	+
	+ def handle_incoming(
	+ %{
	+ "type" => "Undo",
	+ "object" => %{"type" => "Block", "object" => blocked},
	+ "actor" => blocker,
	+ "id" => id
	+ } = _data
	+ ) do
	+ with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
	+ %User{} = blocker <- User.get_or_fetch_by_ap_id(blocker),
	+ {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
	+ User.unblock(blocker, blocked)
	+ {:ok, activity}
	+ else
	+ e -> :error
	+ end
	+ end
	+
	+ def handle_incoming(
	+ %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = data
	+ ) do
	+ with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
	+ %User{} = blocker = User.get_or_fetch_by_ap_id(blocker),
	+ {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
	+ User.unfollow(blocker, blocked)
	+ User.block(blocker, blocked)
	+ {:ok, activity}
	+ else
	+ e -> :error
	+ end
	+ end
	+
	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Like", "object" => object_id},
	"actor" => actor,
	"id" => id
	} = _data
	) do
	with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <-
	get_obj_helper(object_id) \|\| ActivityPub.fetch_object_from_id(object_id),
	{:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	# TODO
	# Accept
	- # Undo for non-Announce

	def handle_incoming(_), do: :error

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

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

	def set_reply_to_uri(obj), do: obj

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

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

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

	data =
	data
	\|> Map.put("object", object)
	\|> Map.put("@context", "https://www.w3.org/ns/activitystreams")

	{:ok, data}
	end

	def prepare_outgoing(%{"type" => _type} = data) do
	data =
	data
	\|> maybe_fix_object_url
	\|> Map.put("@context", "https://www.w3.org/ns/activitystreams")

	{:ok, data}
	end

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

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

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

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

	def add_mention_tags(object) do
	recipients = object["to"] ++ (object["cc"] \|\| [])

	mentions =
	recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user ->
	%{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
	end)

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

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

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

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

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

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

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

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

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

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

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

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

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

	Repo.update_all(q, [])

	maybe_retire_websub(user.ap_id)

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

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

	Repo.update_all(q, [])
	end

	def upgrade_user_from_ap_id(ap_id, async \\ true) do
	with %User{local: false} = user <- User.get_by_ap_id(ap_id),
	{:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
	data =
	data
	\|> Map.put(:info, Map.merge(user.info, data[:info]))

	already_ap = User.ap_enabled?(user)

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

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

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

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

	Repo.delete_all(q)
	end
	end

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

	def maybe_fix_user_object(data) do
	data
	\|> maybe_fix_user_url
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index a3feca480..831e13b7e 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,374 +1,417 @@
	defmodule Pleroma.Web.ActivityPub.Utils do
	alias Pleroma.{Repo, Web, Object, Activity, User}
	alias Pleroma.Web.Router.Helpers
	alias Pleroma.Web.Endpoint
	alias Ecto.{Changeset, UUID}
	import Ecto.Query

	# Some implementations send the actor URI as the actor field, others send the entire actor object,
	# so figure out what the actor's URI is based on what we have.
	def normalize_actor(actor) do
	cond do
	is_binary(actor) ->
	actor

	is_map(actor) ->
	actor["id"]
	end
	end

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

	def make_json_ld_header do
	%{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"https://w3id.org/security/v1",
	%{
	"manuallyApprovesFollowers" => "as:manuallyApprovesFollowers",
	"sensitive" => "as:sensitive",
	"Hashtag" => "as:Hashtag",
	"ostatus" => "http://ostatus.org#",
	"atomUri" => "ostatus:atomUri",
	"inReplyToAtomUri" => "ostatus:inReplyToAtomUri",
	"conversation" => "ostatus:conversation",
	"toot" => "http://joinmastodon.org/ns#",
	"Emoji" => "toot:Emoji"
	}
	]
	}
	end

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

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

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

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

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

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

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

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

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

	def maybe_federate(_), do: :ok

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

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

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

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

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

	def insert_full_object(_), do: :ok

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

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

	#### Like-related helpers

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

	Repo.one(query)
	end

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

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

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

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

	def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
	with likes <- [actor \| object.data["likes"] \|\| []] \|> Enum.uniq() do
	update_likes_in_object(likes, object)
	end
	end

	def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
	with likes <- (object.data["likes"] \|\| []) \|> List.delete(actor) do
	update_likes_in_object(likes, object)
	end
	end

	#### Follow-related helpers

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

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

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

	Repo.one(query)
	end

	#### Announce-related helpers

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

	Repo.one(query)
	end

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

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

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

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

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

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

	def add_announce_to_object(%Activity{data: %{"actor" => actor}}, object) do
	with announcements <- [actor \| object.data["announcements"] \|\| []] \|> Enum.uniq() do
	update_element_in_object("announcement", announcements, object)
	end
	end

	def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
	with announcements <- (object.data["announcements"] \|\| []) \|> List.delete(actor) do
	update_element_in_object("announcement", announcements, object)
	end
	end

	#### Unfollow-related helpers

	- def make_unfollow_data(follower, followed, follow_activity) do
	- %{
	+ def make_unfollow_data(follower, followed, follow_activity, activity_id) do
	+ data = %{
	"type" => "Undo",
	"actor" => follower.ap_id,
	"to" => [followed.ap_id],
	- "object" => follow_activity.data["id"]
	+ "object" => follow_activity.data
	+ }
	+
	+ if activity_id, do: Map.put(data, "id", activity_id), else: data
	+ end
	+
	+ #### Block-related helpers
	+ def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
	+ query =
	+ from(
	+ activity in Activity,
	+ where:
	+ fragment(
	+ "? @> ?",
	+ activity.data,
	+ ^%{type: "Block", object: blocked_id}
	+ ),
	+ where: activity.actor == ^blocker_id,
	+ order_by: [desc: :id],
	+ limit: 1
	+ )
	+
	+ Repo.one(query)
	+ end
	+
	+ def make_block_data(blocker, blocked, activity_id) do
	+ data = %{
	+ "type" => "Block",
	+ "actor" => blocker.ap_id,
	+ "to" => [blocked.ap_id],
	+ "object" => blocked.ap_id
	+ }
	+
	+ if activity_id, do: Map.put(data, "id", activity_id), else: data
	+ end
	+
	+ def make_unblock_data(blocker, blocked, block_activity, activity_id) do
	+ data = %{
	+ "type" => "Undo",
	+ "actor" => blocker.ap_id,
	+ "to" => [blocked.ap_id],
	+ "object" => block_activity.data
	}
	+
	+ if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	#### Create-related helpers

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

	%{
	"type" => "Create",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	index e6365620e..2c0277124 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	@@ -1,794 +1,789 @@
	defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
	use Pleroma.Web, :controller
	alias Pleroma.{Repo, Activity, User, Notification, Stats}
	alias Pleroma.Web
	alias Pleroma.Web.MastodonAPI.{StatusView, AccountView, MastodonView}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.{CommonAPI, OStatus}
	alias Pleroma.Web.OAuth.{Authorization, Token, App}
	alias Comeonin.Pbkdf2
	import Ecto.Query
	require Logger

	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,
	client_id: app.client_id,
	client_secret: app.client_secret
	}

	json(conn, res)
	end
	end

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

	params =
	if bio = params["note"] do
	Map.put(params, "bio", bio)
	else
	params
	end

	params =
	if name = params["display_name"] do
	Map.put(params, "name", name)
	else
	params
	end

	user =
	if avatar = params["avatar"] do
	with %Plug.Upload{} <- avatar,
	{:ok, object} <- ActivityPub.upload(avatar),
	change = Ecto.Changeset.change(user, %{avatar: object.data}),
	{:ok, user} = User.update_and_set_cache(change) do
	user
	else
	_e -> user
	end
	else
	user
	end

	user =
	if banner = params["header"] do
	with %Plug.Upload{} <- banner,
	{:ok, object} <- ActivityPub.upload(banner),
	new_info <- Map.put(user.info, "banner", object.data),
	change <- User.info_changeset(user, %{info: new_info}),
	{:ok, user} <- User.update_and_set_cache(change) do
	user
	else
	_e -> user
	end
	else
	user
	end

	with changeset <- User.update_changeset(user, params),
	{: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}))
	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})
	json(conn, account)
	end

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

	@instance Application.get_env(:pleroma, :instance)
	@mastodon_api_level "2.3.3"

	def masto_instance(conn, _params) do
	response = %{
	uri: Web.base_url(),
	title: Keyword.get(@instance, :name),
	description: "A Pleroma instance, an alternative fediverse server",
	version: "#{@mastodon_api_level} (compatible; #{Keyword.get(@instance, :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.Formatter.get_custom_emoji()
	\|> Enum.map(fn {shortcode, relative_url} ->
	url = to_string(URI.merge(Web.base_url(), relative_url))

	%{
	"shortcode" => shortcode,
	"static_url" => url,
	"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 \\ false) 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, max_id: min),
	mastodon_api_url(Pleroma.Web.Endpoint, method, param, since_id: max)
	}
	else
	{
	mastodon_api_url(Pleroma.Web.Endpoint, method, max_id: min),
	mastodon_api_url(Pleroma.Web.Endpoint, method, 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)
	\|> Enum.reverse()

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

	def public_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("local_only", params["local"] in [true, "True", "true", "1"])
	\|> Map.put("blocking_user", user)

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

	conn
	\|> add_link_headers(:public_timeline, activities)
	\|> render(StatusView, "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
	# Since Pleroma has no "pinned" posts feature, we'll just set an empty list here
	activities =
	if params["pinned"] == "true" do
	[]
	else
	ActivityPub.fetch_user_activities(user, reading_user, params)
	end

	conn
	\|> add_link_headers(:user_statuses, activities, params["id"])
	\|> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
	end
	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
	render(conn, StatusView, "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(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
	params =
	params
	\|> Map.put("in_reply_to_status_id", params["in_reply_to_id"])
	\|> Map.put("no_attachment_links", true)

	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)

	render(conn, StatusView, "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
	render(conn, StatusView, "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, _, _, %{data: %{"id" => id}}} = CommonAPI.unrepeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
	render(conn, StatusView, "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_activity_by_object_ap_id(id) do
	render(conn, StatusView, "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_activity_by_object_ap_id(id) do
	render(conn, StatusView, "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)
	render(conn, AccountView, "relationships.json", %{user: user, targets: targets})
	end

	def upload(%{assigns: %{user: _}} = conn, %{"file" => file}) do
	with {:ok, object} <- ActivityPub.upload(file) do
	data =
	object.data
	\|> Map.put("id", object.id)

	render(conn, StatusView, "attachment.json", %{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)
	render(conn, 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)
	render(conn, AccountView, "accounts.json", %{users: users, as: :user})
	else
	_ -> json(conn, [])
	end
	end

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

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

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

	# TODO: Pagination
	def followers(conn, %{"id" => id}) do
	with %User{} = user <- Repo.get(User, id),
	{:ok, followers} <- User.get_followers(user) do
	render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
	end
	end

	def following(conn, %{"id" => id}) do
	with %User{} = user <- Repo.get(User, id),
	{:ok, followers} <- User.get_friends(user) do
	render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
	end
	end

	def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
	with %User{} = followed <- Repo.get(User, id),
	{:ok, follower} <- User.follow(follower, followed),
	{:ok, _activity} <- ActivityPub.follow(follower, followed) do
	render(conn, AccountView, "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.follow(follower, followed),
	{:ok, _activity} <- ActivityPub.follow(follower, followed) do
	render(conn, AccountView, "account.json", %{user: followed})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	- # TODO: Clean up and unify
	def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
	with %User{} = followed <- Repo.get(User, id),
	- {:ok, follower, follow_activity} <- User.unfollow(follower, followed),
	- {:ok, _activity} <-
	- ActivityPub.insert(%{
	- "type" => "Undo",
	- "actor" => follower.ap_id,
	- # get latest Follow for these users
	- "object" => follow_activity.data["id"]
	- }) do
	+ {:ok, _activity} <- ActivityPub.unfollow(follower, followed),
	+ {:ok, follower, _} <- User.unfollow(follower, followed) do
	render(conn, AccountView, "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) do
	+ {:ok, blocker} <- User.block(blocker, blocked),
	+ {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	render(conn, AccountView, "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) do
	+ {:ok, blocker} <- User.unblock(blocker, blocked),
	+ {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
	render(conn, AccountView, "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

	# TODO: Use proper query
	def blocks(%{assigns: %{user: user}} = conn, _) do
	with blocked_users <- user.info["blocks"] \|\| [],
	accounts <- Enum.map(blocked_users, fn ap_id -> User.get_cached_by_ap_id(ap_id) end) do
	res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
	json(conn, res)
	end
	end

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

	fetched =
	if Regex.match?(~r/https?:/, query) do
	with {:ok, activities} <- OStatus.fetch_activity_from_url(query) do
	activities
	\|> Enum.filter(fn
	%{data: %{"type" => "Create"}} -> true
	_ -> false
	end)
	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]
	)

	statuses = Repo.all(q) ++ fetched

	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")

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

	json(conn, res)
	end

	def favourites(%{assigns: %{user: user}} = conn, _) do
	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
	\|> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
	end

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

	if user && token do
	mastodon_emoji = mastodonized_emoji()
	accounts = Map.put(%{}, user.id, AccountView.render("account.json", %{user: 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,
	reduce_motion: false
	},
	compose: %{
	me: "#{user.id}",
	default_privacy: "public",
	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:
	Map.get(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: Keyword.get(@instance, :limit)
	}
	\|> Jason.encode!()

	conn
	\|> put_layout(false)
	\|> render(MastodonView, "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
	with new_info <- Map.put(user.info, "settings", settings),
	change <- User.info_changeset(user, %{info: new_info}),
	{:ok, _user} <- User.update_and_set_cache(change) do
	conn
	\|> json(%{})
	else
	e ->
	conn
	\|> json(%{error: inspect(e)})
	end
	end

	def login(conn, _) do
	conn
	\|> render(MastodonView, "login.html", %{error: false})
	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 login_post(conn, %{"authorization" => %{"name" => name, "password" => password}}) do
	with %User{} = user <- User.get_by_nickname_or_email(name),
	true <- Pbkdf2.checkpw(password, user.password_hash),
	{:ok, app} <- get_or_make_app(),
	{:ok, auth} <- Authorization.create_authorization(app, user),
	{:ok, token} <- Token.exchange_token(app, auth) do
	conn
	\|> put_session(:oauth_token, token.token)
	\|> redirect(to: "/web/getting-started")
	else
	_e ->
	conn
	\|> render(MastodonView, "login.html", %{error: "Wrong username or password"})
	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
	render(conn, AccountView, "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"])

	created_at =
	NaiveDateTime.to_iso8601(created_at)
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)

	case activity.data["type"] do
	"Create" ->
	%{
	id: id,
	type: "mention",
	created_at: created_at,
	account: AccountView.render("account.json", %{user: actor}),
	status: StatusView.render("status.json", %{activity: activity, for: user})
	}

	"Like" ->
	liked_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])

	%{
	id: id,
	type: "favourite",
	created_at: created_at,
	account: AccountView.render("account.json", %{user: actor}),
	status: StatusView.render("status.json", %{activity: liked_activity, for: user})
	}

	"Announce" ->
	announced_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])

	%{
	id: id,
	type: "reblog",
	created_at: created_at,
	account: AccountView.render("account.json", %{user: actor}),
	status: StatusView.render("status.json", %{activity: announced_activity, for: user})
	}

	"Follow" ->
	%{
	id: id,
	type: "follow",
	created_at: created_at,
	account: AccountView.render("account.json", %{user: actor})
	}

	_ ->
	nil
	end
	end
	end
	diff --git a/lib/pleroma/web/ostatus/activity_representer.ex b/lib/pleroma/web/ostatus/activity_representer.ex
	index 64cadba1b..4179d86c9 100644
	--- a/lib/pleroma/web/ostatus/activity_representer.ex
	+++ b/lib/pleroma/web/ostatus/activity_representer.ex
	@@ -1,309 +1,306 @@
	defmodule Pleroma.Web.OStatus.ActivityRepresenter do
	alias Pleroma.{Activity, User, Object}
	alias Pleroma.Web.OStatus.UserRepresenter
	require Logger

	defp get_href(id) do
	with %Object{data: %{"external_url" => external_url}} <- Object.get_cached_by_ap_id(id) do
	external_url
	else
	_e -> id
	end
	end

	defp get_in_reply_to(%{"object" => %{"inReplyTo" => in_reply_to}}) do
	[
	{:"thr:in-reply-to",
	[ref: to_charlist(in_reply_to), href: to_charlist(get_href(in_reply_to))], []}
	]
	end

	defp get_in_reply_to(_), do: []

	defp get_mentions(to) do
	Enum.map(to, fn id ->
	cond do
	# Special handling for the AP/Ostatus public collections
	"https://www.w3.org/ns/activitystreams#Public" == id ->
	{:link,
	[
	rel: "mentioned",
	"ostatus:object-type": "http://activitystrea.ms/schema/1.0/collection",
	href: "http://activityschema.org/collection/public"
	], []}

	# Ostatus doesn't handle follower collections, ignore these.
	Regex.match?(~r/^#{Pleroma.Web.base_url()}.+followers$/, id) ->
	[]

	true ->
	{:link,
	[
	rel: "mentioned",
	"ostatus:object-type": "http://activitystrea.ms/schema/1.0/person",
	href: id
	], []}
	end
	end)
	end

	defp get_links(%{local: true, data: data}) do
	h = fn str -> [to_charlist(str)] end

	[
	{:link, [type: ['application/atom+xml'], href: h.(data["object"]["id"]), rel: 'self'], []},
	{:link, [type: ['text/html'], href: h.(data["object"]["id"]), rel: 'alternate'], []}
	]
	end

	defp get_links(%{
	local: false,
	data: %{
	"object" => %{
	"external_url" => external_url
	}
	}
	}) do
	h = fn str -> [to_charlist(str)] end

	[
	{:link, [type: ['text/html'], href: h.(external_url), rel: 'alternate'], []}
	]
	end

	defp get_links(_activity), do: []

	defp get_emoji_links(emojis) do
	Enum.map(emojis, fn {emoji, file} ->
	{:link, [name: to_charlist(emoji), rel: 'emoji', href: to_charlist(file)], []}
	end)
	end

	def to_simple_form(activity, user, with_author \\ false)

	def to_simple_form(%{data: %{"object" => %{"type" => "Note"}}} = activity, user, with_author) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["object"]["published"]
	inserted_at = activity.data["object"]["published"]

	attachments =
	Enum.map(activity.data["object"]["attachment"] \|\| [], fn attachment ->
	url = hd(attachment["url"])

	{:link,
	[rel: 'enclosure', href: to_charlist(url["href"]), type: to_charlist(url["mediaType"])],
	[]}
	end)

	in_reply_to = get_in_reply_to(activity.data)
	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []
	mentions = activity.recipients \|> get_mentions

	categories =
	(activity.data["object"]["tag"] \|\| [])
	\|> Enum.map(fn tag ->
	if is_binary(tag) do
	{:category, [term: to_charlist(tag)], []}
	else
	nil
	end
	end)
	\|> Enum.filter(& &1)

	emoji_links = get_emoji_links(activity.data["object"]["emoji"] \|\| %{})

	summary =
	if activity.data["object"]["summary"] do
	[{:summary, [], h.(activity.data["object"]["summary"])}]
	else
	[]
	end

	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/note']},
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/post']},
	# For notes, federate the object id.
	{:id, h.(activity.data["object"]["id"])},
	{:title, ['New note by #{user.nickname}']},
	{:content, [type: 'html'],
	h.(activity.data["object"]["content"] \|> String.replace(~r/[\n\r]/, ""))},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)},
	{:"ostatus:conversation", [ref: h.(activity.data["context"])],
	h.(activity.data["context"])},
	{:link, [ref: h.(activity.data["context"]), rel: 'ostatus:conversation'], []}
	] ++
	summary ++
	get_links(activity) ++
	categories ++ attachments ++ in_reply_to ++ author ++ mentions ++ emoji_links
	end

	def to_simple_form(%{data: %{"type" => "Like"}} = activity, user, with_author) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["published"]
	inserted_at = activity.data["published"]

	_in_reply_to = get_in_reply_to(activity.data)
	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []
	mentions = activity.recipients \|> get_mentions

	[
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/favorite']},
	{:id, h.(activity.data["id"])},
	{:title, ['New favorite by #{user.nickname}']},
	{:content, [type: 'html'], ['#{user.nickname} favorited something']},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)},
	{:"activity:object",
	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/note']},
	# For notes, federate the object id.
	{:id, h.(activity.data["object"])}
	]},
	{:"ostatus:conversation", [ref: h.(activity.data["context"])],
	h.(activity.data["context"])},
	{:link, [ref: h.(activity.data["context"]), rel: 'ostatus:conversation'], []},
	{:link, [rel: 'self', type: ['application/atom+xml'], href: h.(activity.data["id"])], []},
	{:"thr:in-reply-to", [ref: to_charlist(activity.data["object"])], []}
	] ++ author ++ mentions
	end

	def to_simple_form(%{data: %{"type" => "Announce"}} = activity, user, with_author) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["published"]
	inserted_at = activity.data["published"]

	_in_reply_to = get_in_reply_to(activity.data)
	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []

	retweeted_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
	retweeted_user = User.get_cached_by_ap_id(retweeted_activity.data["actor"])

	retweeted_xml = to_simple_form(retweeted_activity, retweeted_user, true)

	mentions = activity.recipients \|> get_mentions

	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/activity']},
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/share']},
	{:id, h.(activity.data["id"])},
	{:title, ['#{user.nickname} repeated a notice']},
	{:content, [type: 'html'], ['RT #{retweeted_activity.data["object"]["content"]}']},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)},
	{:"ostatus:conversation", [ref: h.(activity.data["context"])],
	h.(activity.data["context"])},
	{:link, [ref: h.(activity.data["context"]), rel: 'ostatus:conversation'], []},
	{:link, [rel: 'self', type: ['application/atom+xml'], href: h.(activity.data["id"])], []},
	{:"activity:object", retweeted_xml}
	] ++ mentions ++ author
	end

	def to_simple_form(%{data: %{"type" => "Follow"}} = activity, user, with_author) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["published"]
	inserted_at = activity.data["published"]

	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []

	mentions = (activity.recipients \|\| []) \|> get_mentions

	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/activity']},
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/follow']},
	{:id, h.(activity.data["id"])},
	{:title, ['#{user.nickname} started following #{activity.data["object"]}']},
	{:content, [type: 'html'],
	['#{user.nickname} started following #{activity.data["object"]}']},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)},
	{:"activity:object",
	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/person']},
	{:id, h.(activity.data["object"])},
	{:uri, h.(activity.data["object"])}
	]},
	{:link, [rel: 'self', type: ['application/atom+xml'], href: h.(activity.data["id"])], []}
	] ++ mentions ++ author
	end

	# Only undos of follow for now. Will need to get redone once there are more
	- def to_simple_form(%{data: %{"type" => "Undo"}} = activity, user, with_author) do
	+ def to_simple_form(
	+ %{data: %{"type" => "Undo", "object" => %{"type" => "Follow"} = follow_activity}} =
	+ activity,
	+ user,
	+ with_author
	+ ) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["published"]
	inserted_at = activity.data["published"]

	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []

	- follow_activity =
	- if is_map(activity.data["object"]) do
	- Activity.get_by_ap_id(activity.data["object"]["id"])
	- else
	- Activity.get_by_ap_id(activity.data["object"])
	- end
	-
	mentions = (activity.recipients \|\| []) \|> get_mentions
	+ follow_activity = Activity.get_by_ap_id(follow_activity["id"])

	- if follow_activity do
	- [
	- {:"activity:object-type", ['http://activitystrea.ms/schema/1.0/activity']},
	- {:"activity:verb", ['http://activitystrea.ms/schema/1.0/unfollow']},
	- {:id, h.(activity.data["id"])},
	- {:title, ['#{user.nickname} stopped following #{follow_activity.data["object"]}']},
	- {:content, [type: 'html'],
	- ['#{user.nickname} stopped following #{follow_activity.data["object"]}']},
	- {:published, h.(inserted_at)},
	- {:updated, h.(updated_at)},
	- {:"activity:object",
	- [
	- {:"activity:object-type", ['http://activitystrea.ms/schema/1.0/person']},
	- {:id, h.(follow_activity.data["object"])},
	- {:uri, h.(follow_activity.data["object"])}
	- ]},
	- {:link, [rel: 'self', type: ['application/atom+xml'], href: h.(activity.data["id"])], []}
	- ] ++ mentions ++ author
	- end
	+ [
	+ {:"activity:object-type", ['http://activitystrea.ms/schema/1.0/activity']},
	+ {:"activity:verb", ['http://activitystrea.ms/schema/1.0/unfollow']},
	+ {:id, h.(activity.data["id"])},
	+ {:title, ['#{user.nickname} stopped following #{follow_activity.data["object"]}']},
	+ {:content, [type: 'html'],
	+ ['#{user.nickname} stopped following #{follow_activity.data["object"]}']},
	+ {:published, h.(inserted_at)},
	+ {:updated, h.(updated_at)},
	+ {:"activity:object",
	+ [
	+ {:"activity:object-type", ['http://activitystrea.ms/schema/1.0/person']},
	+ {:id, h.(follow_activity.data["object"])},
	+ {:uri, h.(follow_activity.data["object"])}
	+ ]},
	+ {:link, [rel: 'self', type: ['application/atom+xml'], href: h.(activity.data["id"])], []}
	+ ] ++ mentions ++ author
	end

	def to_simple_form(%{data: %{"type" => "Delete"}} = activity, user, with_author) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["published"]
	inserted_at = activity.data["published"]

	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []

	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/activity']},
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/delete']},
	{:id, h.(activity.data["object"])},
	{:title, ['An object was deleted']},
	{:content, [type: 'html'], ['An object was deleted']},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)}
	] ++ author
	end

	def to_simple_form(_, _, _), do: nil

	def wrap_with_entry(simple_form) do
	[
	{
	:entry,
	[
	xmlns: 'http://www.w3.org/2005/Atom',
	"xmlns:thr": 'http://purl.org/syndication/thread/1.0',
	"xmlns:activity": 'http://activitystrea.ms/spec/1.0/',
	"xmlns:poco": 'http://portablecontacts.net/spec/1.0',
	"xmlns:ostatus": 'http://ostatus.org/schema/1.0'
	],
	simple_form
	}
	]
	end
	end
	diff --git a/lib/pleroma/web/ostatus/handlers/unfollow_handler.ex b/lib/pleroma/web/ostatus/handlers/unfollow_handler.ex
	new file mode 100644
	index 000000000..a115bf4c8
	--- /dev/null
	+++ b/lib/pleroma/web/ostatus/handlers/unfollow_handler.ex
	@@ -0,0 +1,17 @@
	+defmodule Pleroma.Web.OStatus.UnfollowHandler do
	+ alias Pleroma.Web.{XML, OStatus}
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.User
	+
	+ def handle(entry, doc) do
	+ with {:ok, actor} <- OStatus.find_make_or_update_user(doc),
	+ id when not is_nil(id) <- XML.string_from_xpath("/entry/id", entry),
	+ followed_uri when not is_nil(followed_uri) <-
	+ XML.string_from_xpath("/entry/activity:object/id", entry),
	+ {:ok, followed} <- OStatus.find_or_make_user(followed_uri),
	+ {:ok, activity} <- ActivityPub.unfollow(actor, followed, id, false) do
	+ User.unfollow(actor, followed)
	+ {:ok, activity}
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/ostatus/ostatus.ex b/lib/pleroma/web/ostatus/ostatus.ex
	index 5c4a1fd69..f0ff0624f 100644
	--- a/lib/pleroma/web/ostatus/ostatus.ex
	+++ b/lib/pleroma/web/ostatus/ostatus.ex
	@@ -1,383 +1,386 @@
	defmodule Pleroma.Web.OStatus do
	@httpoison Application.get_env(:pleroma, :httpoison)

	import Ecto.Query
	import Pleroma.Web.XML
	require Logger

	alias Pleroma.{Repo, User, Web, Object, Activity}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.{WebFinger, Websub}
	- alias Pleroma.Web.OStatus.{FollowHandler, NoteHandler, DeleteHandler}
	+ alias Pleroma.Web.OStatus.{FollowHandler, UnfollowHandler, NoteHandler, DeleteHandler}
	alias Pleroma.Web.ActivityPub.Transmogrifier

	def feed_path(user) do
	"#{user.ap_id}/feed.atom"
	end

	def pubsub_path(user) do
	"#{Web.base_url()}/push/hub/#{user.nickname}"
	end

	def salmon_path(user) do
	"#{user.ap_id}/salmon"
	end

	def remote_follow_path do
	"#{Web.base_url()}/ostatus_subscribe?acct={uri}"
	end

	def handle_incoming(xml_string) do
	with doc when doc != :error <- parse_document(xml_string) do
	entries = :xmerl_xpath.string('//entry', doc)

	activities =
	Enum.map(entries, fn entry ->
	{:xmlObj, :string, object_type} =
	:xmerl_xpath.string('string(/entry/activity:object-type[1])', entry)

	{:xmlObj, :string, verb} = :xmerl_xpath.string('string(/entry/activity:verb[1])', entry)
	Logger.debug("Handling #{verb}")

	try do
	case verb do
	'http://activitystrea.ms/schema/1.0/delete' ->
	with {:ok, activity} <- DeleteHandler.handle_delete(entry, doc), do: activity

	'http://activitystrea.ms/schema/1.0/follow' ->
	with {:ok, activity} <- FollowHandler.handle(entry, doc), do: activity

	+ 'http://activitystrea.ms/schema/1.0/unfollow' ->
	+ with {:ok, activity} <- UnfollowHandler.handle(entry, doc), do: activity
	+
	'http://activitystrea.ms/schema/1.0/share' ->
	with {:ok, activity, retweeted_activity} <- handle_share(entry, doc),
	do: [activity, retweeted_activity]

	'http://activitystrea.ms/schema/1.0/favorite' ->
	with {:ok, activity, favorited_activity} <- handle_favorite(entry, doc),
	do: [activity, favorited_activity]

	_ ->
	case object_type do
	'http://activitystrea.ms/schema/1.0/note' ->
	with {:ok, activity} <- NoteHandler.handle_note(entry, doc), do: activity

	'http://activitystrea.ms/schema/1.0/comment' ->
	with {:ok, activity} <- NoteHandler.handle_note(entry, doc), do: activity

	_ ->
	Logger.error("Couldn't parse incoming document")
	nil
	end
	end
	rescue
	e ->
	Logger.error("Error occured while handling activity")
	Logger.error(xml_string)
	Logger.error(inspect(e))
	nil
	end
	end)
	\|> Enum.filter(& &1)

	{:ok, activities}
	else
	_e -> {:error, []}
	end
	end

	def make_share(entry, doc, retweeted_activity) do
	with {:ok, actor} <- find_make_or_update_user(doc),
	%Object{} = object <- Object.get_by_ap_id(retweeted_activity.data["object"]["id"]),
	id when not is_nil(id) <- string_from_xpath("/entry/id", entry),
	{:ok, activity, _object} = ActivityPub.announce(actor, object, id, false) do
	{:ok, activity}
	end
	end

	def handle_share(entry, doc) do
	with {:ok, retweeted_activity} <- get_or_build_object(entry),
	{:ok, activity} <- make_share(entry, doc, retweeted_activity) do
	{:ok, activity, retweeted_activity}
	else
	e -> {:error, e}
	end
	end

	def make_favorite(entry, doc, favorited_activity) do
	with {:ok, actor} <- find_make_or_update_user(doc),
	%Object{} = object <- Object.get_by_ap_id(favorited_activity.data["object"]["id"]),
	id when not is_nil(id) <- string_from_xpath("/entry/id", entry),
	{:ok, activity, _object} = ActivityPub.like(actor, object, id, false) do
	{:ok, activity}
	end
	end

	def get_or_build_object(entry) do
	with {:ok, activity} <- get_or_try_fetching(entry) do
	{:ok, activity}
	else
	_e ->
	with [object] <- :xmerl_xpath.string('/entry/activity:object', entry) do
	NoteHandler.handle_note(object, object)
	end
	end
	end

	def get_or_try_fetching(entry) do
	Logger.debug("Trying to get entry from db")

	with id when not is_nil(id) <- string_from_xpath("//activity:object[1]/id", entry),
	%Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
	{:ok, activity}
	else
	_ ->
	Logger.debug("Couldn't get, will try to fetch")

	with href when not is_nil(href) <-
	string_from_xpath("//activity:object[1]/link[@type=\"text/html\"]/@href", entry),
	{:ok, [favorited_activity]} <- fetch_activity_from_url(href) do
	{:ok, favorited_activity}
	else
	e -> Logger.debug("Couldn't find href: #{inspect(e)}")
	end
	end
	end

	def handle_favorite(entry, doc) do
	with {:ok, favorited_activity} <- get_or_try_fetching(entry),
	{:ok, activity} <- make_favorite(entry, doc, favorited_activity) do
	{:ok, activity, favorited_activity}
	else
	e -> {:error, e}
	end
	end

	def get_attachments(entry) do
	:xmerl_xpath.string('/entry/link[@rel="enclosure"]', entry)
	\|> Enum.map(fn enclosure ->
	with href when not is_nil(href) <- string_from_xpath("/link/@href", enclosure),
	type when not is_nil(type) <- string_from_xpath("/link/@type", enclosure) do
	%{
	"type" => "Attachment",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => type,
	"href" => href
	}
	]
	}
	end
	end)
	\|> Enum.filter(& &1)
	end

	@doc """
	Gets the content from a an entry.
	"""
	def get_content(entry) do
	string_from_xpath("//content", entry)
	end

	@doc """
	Get the cw that mastodon uses.
	"""
	def get_cw(entry) do
	with cw when not is_nil(cw) <- string_from_xpath("/*/summary", entry) do
	cw
	else
	_e -> nil
	end
	end

	def get_tags(entry) do
	:xmerl_xpath.string('//category', entry)
	\|> Enum.map(fn category -> string_from_xpath("/category/@term", category) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(&String.downcase/1)
	end

	def maybe_update(doc, user) do
	if "true" == string_from_xpath("//author[1]/ap_enabled", doc) do
	Transmogrifier.upgrade_user_from_ap_id(user.ap_id)
	else
	maybe_update_ostatus(doc, user)
	end
	end

	def maybe_update_ostatus(doc, user) do
	old_data = %{
	avatar: user.avatar,
	bio: user.bio,
	name: user.name,
	info: user.info
	}

	with false <- user.local,
	avatar <- make_avatar_object(doc),
	bio <- string_from_xpath("//author[1]/summary", doc),
	name <- string_from_xpath("//author[1]/poco:displayName", doc),
	info <-
	Map.put(user.info, "banner", make_avatar_object(doc, "header") \|\| user.info["banner"]),
	new_data <- %{
	avatar: avatar \|\| old_data.avatar,
	name: name \|\| old_data.name,
	bio: bio \|\| old_data.bio,
	info: info \|\| old_data.info
	},
	false <- new_data == old_data do
	change = Ecto.Changeset.change(user, new_data)
	Repo.update(change)
	else
	_ ->
	{:ok, user}
	end
	end

	def find_make_or_update_user(doc) do
	uri = string_from_xpath("//author/uri[1]", doc)

	with {:ok, user} <- find_or_make_user(uri) do
	maybe_update(doc, user)
	end
	end

	def find_or_make_user(uri) do
	query = from(user in User, where: user.ap_id == ^uri)

	user = Repo.one(query)

	if is_nil(user) do
	make_user(uri)
	else
	{:ok, user}
	end
	end

	def make_user(uri, update \\ false) do
	with {:ok, info} <- gather_user_info(uri) do
	data = %{
	name: info["name"],
	nickname: info["nickname"] <> "@" <> info["host"],
	ap_id: info["uri"],
	info: info,
	avatar: info["avatar"],
	bio: info["bio"]
	}

	with false <- update,
	%User{} = user <- User.get_by_ap_id(data.ap_id) do
	{:ok, user}
	else
	_e -> User.insert_or_update_user(data)
	end
	end
	end

	# TODO: Just takes the first one for now.
	def make_avatar_object(author_doc, rel \\ "avatar") do
	href = string_from_xpath("//author[1]/link[@rel=\"#{rel}\"]/@href", author_doc)
	type = string_from_xpath("//author[1]/link[@rel=\"#{rel}\"]/@type", author_doc)

	if href do
	%{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => type,
	"href" => href
	}
	]
	}
	else
	nil
	end
	end

	def gather_user_info(username) do
	with {:ok, webfinger_data} <- WebFinger.finger(username),
	{:ok, feed_data} <- Websub.gather_feed_data(webfinger_data["topic"]) do
	{:ok, Map.merge(webfinger_data, feed_data) \|> Map.put("fqn", username)}
	else
	e ->
	Logger.debug(fn -> "Couldn't gather info for #{username}" end)
	{:error, e}
	end
	end

	# Regex-based 'parsing' so we don't have to pull in a full html parser
	# It's a hack anyway. Maybe revisit this in the future
	@mastodon_regex ~r/<link href='(.*)' rel='alternate' type='application\/atom\+xml'>/
	@gs_regex ~r/<link title=.* href="(.*)" type="application\/atom\+xml" rel="alternate">/
	@gs_classic_regex ~r/<link rel="alternate" href="(.)" type="application\/atom\+xml" title=.>/
	def get_atom_url(body) do
	cond do
	Regex.match?(@mastodon_regex, body) ->
	[[_, match]] = Regex.scan(@mastodon_regex, body)
	{:ok, match}

	Regex.match?(@gs_regex, body) ->
	[[_, match]] = Regex.scan(@gs_regex, body)
	{:ok, match}

	Regex.match?(@gs_classic_regex, body) ->
	[[_, match]] = Regex.scan(@gs_classic_regex, body)
	{:ok, match}

	true ->
	Logger.debug(fn -> "Couldn't find Atom link in #{inspect(body)}" end)
	{:error, "Couldn't find the Atom link"}
	end
	end

	def fetch_activity_from_atom_url(url) do
	with true <- String.starts_with?(url, "http"),
	{:ok, %{body: body, status_code: code}} when code in 200..299 <-
	@httpoison.get(
	url,
	[Accept: "application/atom+xml"],
	follow_redirect: true,
	timeout: 10000,
	recv_timeout: 20000
	) do
	Logger.debug("Got document from #{url}, handling...")
	handle_incoming(body)
	else
	e ->
	Logger.debug("Couldn't get #{url}: #{inspect(e)}")
	e
	end
	end

	def fetch_activity_from_html_url(url) do
	Logger.debug("Trying to fetch #{url}")

	with true <- String.starts_with?(url, "http"),
	{:ok, %{body: body}} <-
	@httpoison.get(url, [], follow_redirect: true, timeout: 10000, recv_timeout: 20000),
	{:ok, atom_url} <- get_atom_url(body) do
	fetch_activity_from_atom_url(atom_url)
	else
	e ->
	Logger.debug("Couldn't get #{url}: #{inspect(e)}")
	e
	end
	end

	def fetch_activity_from_url(url) do
	try do
	with {:ok, activities} when length(activities) > 0 <- fetch_activity_from_atom_url(url) do
	{:ok, activities}
	else
	_e ->
	with {:ok, activities} <- fetch_activity_from_html_url(url) do
	{:ok, activities}
	end
	end
	rescue
	e ->
	Logger.debug("Couldn't get #{url}: #{inspect(e)}")
	{:error, "Couldn't get #{url}: #{inspect(e)}"}
	end
	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 c2e1f07a5..57837205e 100644
	--- a/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	+++ b/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	@@ -1,224 +1,224 @@
	# 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}
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Formatter

	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}"
	+ 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"] \|\| [])

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

	attentions =
	activity.recipients
	\|> 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 = activity.data["object"]["summary"]

	content =
	if !!summary and summary != "" do
	"<span>#{activity.data["object"]["summary"]}</span><br />#{content}</span>"
	else
	content
	end

	html =
	HtmlSanitizeEx.basic_html(content)
	\|> Formatter.emojify(object["emoji"])

	%{
	"id" => activity.id,
	"uri" => activity.data["object"]["id"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => html,
	"text" => HtmlSanitizeEx.strip_tags(content),
	"is_local" => activity.local,
	"is_post_verb" => true,
	"created_at" => created_at,
	"in_reply_to_status_id" => object["inReplyToStatusId"],
	"statusnet_conversation_id" => conversation_id,
	"attachments" => (object["attachment"] \|\| []) \|> ObjectRepresenter.enum_to_list(opts),
	"attentions" => attentions,
	"fave_num" => like_count,
	"repeat_num" => announcement_count,
	"favorited" => to_boolean(favorited),
	"repeated" => to_boolean(repeated),
	"external_url" => object["external_url"] \|\| object["id"],
	"tags" => tags,
	"activity_type" => "post",
	"possibly_sensitive" => possibly_sensitive,
	"visibility" => Pleroma.Web.MastodonAPI.StatusView.get_visibility(object)
	}
	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/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index 722e436e2..3ccdaed6f 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,278 +1,273 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
	alias Pleroma.{User, Activity, Repo, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.{OStatus, CommonAPI}
	import Ecto.Query

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

	def create_status(%User{} = user, %{"status" => _} = data) do
	CommonAPI.post(user, data)
	end

	def delete(%User{} = user, id) do
	# TwitterAPI does not have an "unretweet" endpoint; instead this is done
	# via the "destroy" endpoint. Therefore, we need to handle
	# when the status to "delete" is actually an Announce (repeat) object.
	with %Activity{data: %{"type" => type}} <- Repo.get(Activity, id) do
	case type do
	"Announce" -> unrepeat(user, id)
	_ -> CommonAPI.delete(id, user)
	end
	end
	end

	def follow(%User{} = follower, params) do
	with {:ok, %User{} = followed} <- get_user(params),
	{:ok, follower} <- User.follow(follower, followed),
	{:ok, activity} <- ActivityPub.follow(follower, followed) do
	{:ok, follower, followed, activity}
	else
	err -> err
	end
	end

	def unfollow(%User{} = follower, params) do
	with {:ok, %User{} = unfollowed} <- get_user(params),
	{:ok, follower, follow_activity} <- User.unfollow(follower, unfollowed),
	- {:ok, _activity} <-
	- ActivityPub.insert(%{
	- "type" => "Undo",
	- "actor" => follower.ap_id,
	- # get latest Follow for these users
	- "object" => follow_activity.data["id"],
	- "published" => make_date()
	- }) do
	+ {:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed) do
	{:ok, follower, unfollowed}
	else
	err -> err
	end
	end

	def block(%User{} = blocker, params) do
	with {:ok, %User{} = blocked} <- get_user(params),
	- {:ok, blocker} <- User.block(blocker, blocked) do
	+ {:ok, blocker} <- User.block(blocker, blocked),
	+ {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	{:ok, blocker, blocked}
	else
	err -> err
	end
	end

	def unblock(%User{} = blocker, params) do
	with {:ok, %User{} = blocked} <- get_user(params),
	- {:ok, blocker} <- User.unblock(blocker, blocked) do
	+ {:ok, blocker} <- User.unblock(blocker, blocked),
	+ {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
	{:ok, blocker, blocked}
	else
	err -> err
	end
	end

	def repeat(%User{} = user, ap_id_or_id) do
	with {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	defp unrepeat(%User{} = user, ap_id_or_id) do
	with {:ok, _unannounce, activity, _object} <- CommonAPI.unrepeat(ap_id_or_id, user) do
	{:ok, activity}
	end
	end

	def fav(%User{} = user, ap_id_or_id) do
	with {:ok, _fav, %{data: %{"id" => id}}} = CommonAPI.favorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def unfav(%User{} = user, ap_id_or_id) do
	with {:ok, _unfav, _fav, %{data: %{"id" => id}}} = CommonAPI.unfavorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def upload(%Plug.Upload{} = file, format \\ "xml") do
	{:ok, object} = ActivityPub.upload(file)

	url = List.first(object.data["url"])
	href = url["href"]
	type = url["mediaType"]

	case format do
	"xml" ->
	# Fake this as good as possible...
	"""
	<?xml version="1.0" encoding="UTF-8"?>
	<rsp stat="ok" xmlns:atom="http://www.w3.org/2005/Atom">
	<mediaid>#{object.id}</mediaid>
	<media_id>#{object.id}</media_id>
	<media_id_string>#{object.id}</media_id_string>
	<media_url>#{href}</media_url>
	<mediaurl>#{href}</mediaurl>
	<atom:link rel="enclosure" href="#{href}" type="#{type}"></atom:link>
	</rsp>
	"""

	"json" ->
	%{
	media_id: object.id,
	media_id_string: "#{object.id}}",
	media_url: href,
	size: 0
	}
	\|> Jason.encode!()
	end
	end

	def register_user(params) do
	params = %{
	nickname: params["nickname"],
	name: params["fullname"],
	bio: params["bio"],
	email: params["email"],
	password: params["password"],
	password_confirmation: params["confirm"]
	}

	changeset = User.register_changeset(%User{}, params)

	with {:ok, user} <- Repo.insert(changeset) do
	{:ok, user}
	else
	{:error, changeset} ->
	errors =
	Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
	\|> Jason.encode!()

	{:error, %{error: errors}}
	end
	end

	def get_by_id_or_nickname(id_or_nickname) do
	if !is_integer(id_or_nickname) && :error == Integer.parse(id_or_nickname) do
	Repo.get_by(User, nickname: id_or_nickname)
	else
	Repo.get(User, id_or_nickname)
	end
	end

	def get_user(user \\ nil, params) do
	case params do
	%{"user_id" => user_id} ->
	case target = get_by_id_or_nickname(user_id) do
	nil ->
	{:error, "No user with such user_id"}

	_ ->
	{:ok, target}
	end

	%{"screen_name" => nickname} ->
	case target = Repo.get_by(User, nickname: nickname) do
	nil ->
	{:error, "No user with such screen_name"}

	_ ->
	{:ok, target}
	end

	_ ->
	if user do
	{:ok, user}
	else
	{:error, "You need to specify screen_name or user_id"}
	end
	end
	end

	defp parse_int(string, default)

	defp parse_int(string, default) when is_binary(string) do
	with {n, _} <- Integer.parse(string) do
	n
	else
	_e -> default
	end
	end

	defp parse_int(_, default), do: default

	def search(_user, %{"q" => query} = params) do
	limit = parse_int(params["rpp"], 20)
	page = parse_int(params["page"], 1)
	offset = (page - 1) * limit

	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: ^limit,
	offset: ^offset,
	# this one isn't indexed so psql won't take the wrong index.
	order_by: [desc: :inserted_at]
	)

	_activities = Repo.all(q)
	end

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

	# DEPRECATED mostly, context objects are now created at insertion time.
	def context_to_conversation_id(context) do
	with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
	id
	else
	_e ->
	changeset = Object.context_mapping(context)

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

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

	def conversation_id_to_context(id) do
	with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
	context
	else
	_e ->
	{:error, "No such conversation"}
	end
	end

	def get_external_profile(for_user, uri) do
	with %User{} = user <- User.get_or_fetch(uri) do
	spawn(fn ->
	with url <- user.info["topic"],
	{:ok, %{body: body}} <-
	@httpoison.get(url, [], follow_redirect: true, timeout: 10000, recv_timeout: 20000) do
	OStatus.handle_incoming(body)
	end
	end)

	{:ok, UserView.render("show.json", %{user: user, for: for_user})}
	else
	_e ->
	{:error, "Couldn't find user"}
	end
	end
	end
	diff --git a/test/fixtures/mastodon-block-activity.json b/test/fixtures/mastodon-block-activity.json
	new file mode 100644
	index 000000000..186719d2c
	--- /dev/null
	+++ b/test/fixtures/mastodon-block-activity.json
	@@ -0,0 +1,29 @@
	+{
	+ "type": "Block",
	+ "signature": {
	+ "type": "RsaSignature2017",
	+ "signatureValue": "Kn1/UkAQGJVaXBfWLAHcnwHg8YMAUqlEaBuYLazAG+pz5hqivsyrBmPV186Xzr+B4ZLExA9+SnOoNx/GOz4hBm0kAmukNSILAsUd84tcJ2yT9zc1RKtembK4WiwOw7li0+maeDN0HaB6t+6eTqsCWmtiZpprhXD8V1GGT8yG7X24fQ9oFGn+ng7lasbcCC0988Y1eGqNe7KryxcPuQz57YkDapvtONzk8gyLTkZMV4De93MyRHq6GVjQVIgtiYabQAxrX6Q8C+4P/jQoqdWJHEe+MY5JKyNaT/hMPt2Md1ok9fZQBGHlErk22/zy8bSN19GdG09HmIysBUHRYpBLig==",
	+ "creator": "http://mastodon.example.org/users/admin#main-key",
	+ "created": "2018-02-17T13:29:31Z"
	+ },
	+ "object": "http://localtesting.pleroma.lol/users/lain",
	+ "nickname": "lain",
	+ "id": "http://mastodon.example.org/users/admin#follows/2",
	+ "actor": "http://mastodon.example.org/users/admin",
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams",
	+ "https://w3id.org/security/v1",
	+ {
	+ "toot": "http://joinmastodon.org/ns#",
	+ "sensitive": "as:sensitive",
	+ "ostatus": "http://ostatus.org#",
	+ "movedTo": "as:movedTo",
	+ "manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
	+ "inReplyToAtomUri": "ostatus:inReplyToAtomUri",
	+ "conversation": "ostatus:conversation",
	+ "atomUri": "ostatus:atomUri",
	+ "Hashtag": "as:Hashtag",
	+ "Emoji": "toot:Emoji"
	+ }
	+ ]
	+}
	diff --git a/test/fixtures/mastodon-unblock-activity.json b/test/fixtures/mastodon-unblock-activity.json
	new file mode 100644
	index 000000000..f4a2d30dd
	--- /dev/null
	+++ b/test/fixtures/mastodon-unblock-activity.json
	@@ -0,0 +1,34 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams",
	+ "https://w3id.org/security/v1",
	+ {
	+ "toot": "http://joinmastodon.org/ns#",
	+ "sensitive": "as:sensitive",
	+ "ostatus": "http://ostatus.org#",
	+ "movedTo": "as:movedTo",
	+ "manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
	+ "inReplyToAtomUri": "ostatus:inReplyToAtomUri",
	+ "conversation": "ostatus:conversation",
	+ "atomUri": "ostatus:atomUri",
	+ "Hashtag": "as:Hashtag",
	+ "Emoji": "toot:Emoji"
	+ }
	+ ],
	+ "signature": {
	+ "type": "RsaSignature2017",
	+ "signatureValue": "Kn1/UkAQGJVaXBfWLAHcnwHg8YMAUqlEaBuYLazAG+pz5hqivsyrBmPV186Xzr+B4ZLExA9+SnOoNx/GOz4hBm0kAmukNSILAsUd84tcJ2yT9zc1RKtembK4WiwOw7li0+maeDN0HaB6t+6eTqsCWmtiZpprhXD8V1GGT8yG7X24fQ9oFGn+ng7lasbcCC0988Y1eGqNe7KryxcPuQz57YkDapvtONzk8gyLTkZMV4De93MyRHq6GVjQVIgtiYabQAxrX6Q8C+4P/jQoqdWJHEe+MY5JKyNaT/hMPt2Md1ok9fZQBGHlErk22/zy8bSN19GdG09HmIysBUHRYpBLig==",
	+ "creator": "http://mastodon.example.org/users/admin#main-key",
	+ "created": "2018-02-17T13:29:31Z"
	+ },
	+ "type": "Undo",
	+ "object": {
	+ "type": "Block",
	+ "object": "http://localtesting.pleroma.lol/users/lain",
	+ "nickname": "lain",
	+ "id": "http://mastodon.example.org/users/admin#blocks/2",
	+ "actor": "http://mastodon.example.org/users/admin"
	+ },
	+ "actor": "http://mastodon.example.org/users/admin",
	+ "id": "http://mastodon.example.org/users/admin#blocks/2/undo"
	+}
	diff --git a/test/fixtures/mastodon-unfollow-activity.json b/test/fixtures/mastodon-unfollow-activity.json
	new file mode 100644
	index 000000000..ae5ab7c66
	--- /dev/null
	+++ b/test/fixtures/mastodon-unfollow-activity.json
	@@ -0,0 +1,34 @@
	+{
	+ "@context":[
	+ "https://www.w3.org/ns/activitystreams",
	+ "https://w3id.org/security/v1",
	+ {
	+ "toot":"http://joinmastodon.org/ns#",
	+ "sensitive":"as:sensitive",
	+ "ostatus":"http://ostatus.org#",
	+ "movedTo":"as:movedTo",
	+ "manuallyApprovesFollowers":"as:manuallyApprovesFollowers",
	+ "inReplyToAtomUri":"ostatus:inReplyToAtomUri",
	+ "conversation":"ostatus:conversation",
	+ "atomUri":"ostatus:atomUri",
	+ "Hashtag":"as:Hashtag",
	+ "Emoji":"toot:Emoji"
	+ }
	+ ],
	+ "signature":{
	+ "type":"RsaSignature2017",
	+ "signatureValue":"Kn1/UkAQGJVaXBfWLAHcnwHg8YMAUqlEaBuYLazAG+pz5hqivsyrBmPV186Xzr+B4ZLExA9+SnOoNx/GOz4hBm0kAmukNSILAsUd84tcJ2yT9zc1RKtembK4WiwOw7li0+maeDN0HaB6t+6eTqsCWmtiZpprhXD8V1GGT8yG7X24fQ9oFGn+ng7lasbcCC0988Y1eGqNe7KryxcPuQz57YkDapvtONzk8gyLTkZMV4De93MyRHq6GVjQVIgtiYabQAxrX6Q8C+4P/jQoqdWJHEe+MY5JKyNaT/hMPt2Md1ok9fZQBGHlErk22/zy8bSN19GdG09HmIysBUHRYpBLig==",
	+ "creator":"http://mastodon.example.org/users/admin#main-key",
	+ "created":"2018-02-17T13:29:31Z"
	+ },
	+ "type":"Undo",
	+ "object":{
	+ "type":"Follow",
	+ "object":"http://localtesting.pleroma.lol/users/lain",
	+ "nickname":"lain",
	+ "id":"http://mastodon.example.org/users/admin#follows/2",
	+ "actor":"http://mastodon.example.org/users/admin"
	+ },
	+ "actor":"http://mastodon.example.org/users/admin",
	+ "id": "http://mastodon.example.org/users/admin#follow/2/undo"
	+}
	diff --git a/test/fixtures/unfollow.xml b/test/fixtures/unfollow.xml
	new file mode 100644
	index 000000000..7a8f8fd2e
	--- /dev/null
	+++ b/test/fixtures/unfollow.xml
	@@ -0,0 +1,68 @@
	+<?xml version="1.0" encoding="UTF-8"?>
	+<feed xml:lang="en-US" xmlns="http://www.w3.org/2005/Atom" xmlns:thr="http://purl.org/syndication/thread/1.0" xmlns:georss="http://www.georss.org/georss" xmlns:activity="http://activitystrea.ms/spec/1.0/" xmlns:media="http://purl.org/syndication/atommedia" xmlns:poco="http://portablecontacts.net/spec/1.0" xmlns:ostatus="http://ostatus.org/schema/1.0" xmlns:statusnet="http://status.net/schema/api/1/">
	+ <generator uri="https://gnu.io/social" version="1.0.2-dev">GNU social</generator>
	+ <id>https://social.heldscal.la/api/statuses/user_timeline/23211.atom</id>
	+ <title>lambadalambda timeline</title>
	+ <subtitle>Updates from lambadalambda on social.heldscal.la!</subtitle>
	+ <logo>https://social.heldscal.la/avatar/23211-96-20170416114255.jpeg</logo>
	+ <updated>2017-05-07T09:54:49+00:00</updated>
	+<author>
	+ <activity:object-type>http://activitystrea.ms/schema/1.0/person</activity:object-type>
	+ <uri>https://social.heldscal.la/user/23211</uri>
	+ <name>lambadalambda</name>
	+ <summary>Call me Deacon Blues.</summary>
	+ <link rel="alternate" type="text/html" href="https://social.heldscal.la/lambadalambda"/>
	+ <link rel="avatar" type="image/jpeg" media:width="236" media:height="236" href="https://social.heldscal.la/avatar/23211-original-20170416114255.jpeg"/>
	+ <link rel="avatar" type="image/jpeg" media:width="96" media:height="96" href="https://social.heldscal.la/avatar/23211-96-20170416114255.jpeg"/>
	+ <link rel="avatar" type="image/jpeg" media:width="48" media:height="48" href="https://social.heldscal.la/avatar/23211-48-20170416114255.jpeg"/>
	+ <link rel="avatar" type="image/jpeg" media:width="24" media:height="24" href="https://social.heldscal.la/avatar/23211-24-20170416114257.jpeg"/>
	+ <poco:preferredUsername>lambadalambda</poco:preferredUsername>
	+ <poco:displayName>Constance Variable</poco:displayName>
	+ <poco:note>Call me Deacon Blues.</poco:note>
	+ <poco:address>
	+ <poco:formatted>Berlin</poco:formatted>
	+ </poco:address>
	+ <poco:urls>
	+ <poco:type>homepage</poco:type>
	+ <poco:value>https://heldscal.la</poco:value>
	+ <poco:primary>true</poco:primary>
	+ </poco:urls>
	+ <followers url="https://social.heldscal.la/lambadalambda/subscribers"></followers>
	+ <statusnet:profile_info local_id="23211"></statusnet:profile_info>
	+</author>
	+ <link href="https://social.heldscal.la/lambadalambda" rel="alternate" type="text/html"/>
	+ <link href="https://social.heldscal.la/main/sup" rel="http://api.friendfeed.com/2008/03#sup" type="application/json"/>
	+ <link href="https://social.heldscal.la/main/push/hub" rel="hub"/>
	+ <link href="https://social.heldscal.la/main/salmon/user/23211" rel="salmon"/>
	+ <link href="https://social.heldscal.la/main/salmon/user/23211" rel="http://salmon-protocol.org/ns/salmon-replies"/>
	+ <link href="https://social.heldscal.la/main/salmon/user/23211" rel="http://salmon-protocol.org/ns/salmon-mention"/>
	+ <link href="https://social.heldscal.la/api/statuses/user_timeline/23211.atom" rel="self" type="application/atom+xml"/>
	+<entry>
	+ <id>undo:tag:social.heldscal.la,2017-05-07:subscription:23211:person:44803:2017-05-07T09:54:48+00:00</id>
	+ <title>Constance Variable (lambadalambda@social.heldscal.la)'s status on Sunday, 07-May-2017 09:54:49 UTC</title>
	+ <content type="html"><a href="https://social.heldscal.la/lambadalambda">Constance Variable</a> stopped following <a href="https://pawoo.net/@pekorino">ｍｏｎｏ</a>.</content>
	+ <link rel="alternate" type="text/html" href="https://social.heldscal.la/notice/2092981"/>
	+ <activity:verb>http://activitystrea.ms/schema/1.0/unfollow</activity:verb>
	+ <published>2017-05-07T09:54:49+00:00</published>
	+ <updated>2017-05-07T09:54:49+00:00</updated>
	+ <activity:object>
	+ <activity:object-type>http://activitystrea.ms/schema/1.0/person</activity:object-type>
	+ <id>https://pawoo.net/users/pekorino</id>
	+ <title>ｍｏｎｏ</title>
	+ <summary>http://shitposter.club/mono 孤独のグルメ</summary>
	+ <link rel="alternate" type="text/html" href="https://pawoo.net/@pekorino"/>
	+ <link rel="avatar" type="image/png" media:width="96" media:height="96" href="http://social.heldscal.la/theme/neo-gnu/default-avatar-profile.png"/>
	+ <link rel="avatar" type="image/png" media:width="48" media:height="48" href="http://social.heldscal.la/theme/neo-gnu/default-avatar-stream.png"/>
	+ <link rel="avatar" type="image/png" media:width="24" media:height="24" href="http://social.heldscal.la/theme/neo-gnu/default-avatar-mini.png"/>
	+ <poco:preferredUsername>pekorino</poco:preferredUsername>
	+ <poco:displayName>ｍｏｎｏ</poco:displayName>
	+ <poco:note>http://shitposter.club/mono 孤独のグルメ</poco:note>
	+ </activity:object>
	+ <link rel="ostatus:conversation" href="https://social.heldscal.la/conversation/1079786"/>
	+ <ostatus:conversation href="https://social.heldscal.la/conversation/1079786" local_id="1079786" ref="tag:social.heldscal.la,2017-05-07:objectType=thread:nonce=6e80caf94e03029f">tag:social.heldscal.la,2017-05-07:objectType=thread:nonce=6e80caf94e03029f</ostatus:conversation>
	+ <link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	+ <link rel="self" type="application/atom+xml" href="https://social.heldscal.la/api/statuses/show/2092981.atom"/>
	+ <link rel="edit" type="application/atom+xml" href="https://social.heldscal.la/api/statuses/show/2092981.atom"/>
	+ <statusnet:notice_info local_id="2092981" source="activity"></statusnet:notice_info>
	+</entry>
	+</feed>
	diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
	index 9adce84b5..081c202b1 100644
	--- a/test/web/activity_pub/activity_pub_test.exs
	+++ b/test/web/activity_pub/activity_pub_test.exs
	@@ -1,472 +1,505 @@
	defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
	use Pleroma.DataCase
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.{Activity, Object, User}
	alias Pleroma.Builders.ActivityBuilder

	import Pleroma.Factory

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

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

	assert activity == new_activity
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	data = %{
	"ok" => true
	}

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

	given_id = "bla"

	data = %{
	"ok" => true,
	"id" => given_id,
	"context" => "blabla"
	}

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

	test "adds a context when none is there" do
	data = %{
	"id" => "some_id",
	"object" => %{
	"id" => "object_id"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)

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

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	data = %{
	"object" => %{
	"type" => "Note",
	"ok" => true
	}
	}

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

	describe "create activities" do
	test "removes doubled 'to' recipients" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2"]
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, user} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
	assert activities == [activity_two, activity]
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, user} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, user} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_activity_by_object_ap_id(id)
	activity_three = Repo.get(Activity, activity_three.id)

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => nil})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

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

	{:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	activities = ActivityBuilder.insert_list(30)
	last_expected = List.last(activities)

	activities = ActivityPub.fetch_public_activities()
	last = List.last(activities)

	assert length(activities) == 20
	assert last == last_expected
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	later_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id
	last_expected = List.last(later_activities)

	activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})
	last = List.last(activities)

	assert length(activities) == 10
	assert last == last_expected
	end

	test "retrieves ids up to max_id" do
	_first_activities = ActivityBuilder.insert_list(10)
	activities = ActivityBuilder.insert_list(20)
	later_activities = ActivityBuilder.insert_list(10)
	max_id = List.first(later_activities).id
	last_expected = List.last(activities)

	activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})
	last = List.last(activities)

	assert length(activities) == 20
	assert last == last_expected
	end
	end

	describe "like an object" do
	test "adds a like activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)
	user_two = insert(:user)

	{:ok, like_activity, object} = ActivityPub.like(user, object)

	assert like_activity.data["actor"] == user.ap_id
	assert like_activity.data["type"] == "Like"
	assert like_activity.data["object"] == object.data["id"]
	assert like_activity.data["to"] == [User.ap_followers(user), note_activity.data["actor"]]
	assert like_activity.data["context"] == object.data["context"]
	assert object.data["like_count"] == 1
	assert object.data["likes"] == [user.ap_id]

	# Just return the original activity if the user already liked it.
	{:ok, same_like_activity, object} = ActivityPub.like(user, object)

	assert like_activity == same_like_activity
	assert object.data["likes"] == [user.ap_id]

	[note_activity] = Activity.all_by_object_ap_id(object.data["id"])
	assert note_activity.data["object"]["like_count"] == 1

	{:ok, _like_activity, object} = ActivityPub.like(user_two, object)
	assert object.data["like_count"] == 2
	end
	end

	describe "unliking" do
	test "unliking a previously liked object" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	# Unliking something that hasn't been liked does nothing
	{:ok, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	{:ok, like_activity, object} = ActivityPub.like(user, object)
	assert object.data["like_count"] == 1

	{:ok, _, _, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	assert Repo.get(Activity, like_activity.id) == nil
	end
	end

	describe "announcing an object" do
	test "adds an announce activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1
	assert object.data["announcements"] == [user.ap_id]

	assert announce_activity.data["to"] == [
	User.ap_followers(user),
	note_activity.data["actor"]
	]

	assert announce_activity.data["object"] == object.data["id"]
	assert announce_activity.data["actor"] == user.ap_id
	assert announce_activity.data["context"] == object.data["context"]
	end
	end

	describe "unannouncing an object" do
	test "unannouncing a previously announced object" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	# Unannouncing an object that is not announced does nothing
	# {:ok, object} = ActivityPub.unannounce(user, object)
	# assert object.data["announcement_count"] == 0

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1

	{:ok, unannounce_activity, activity, object} = ActivityPub.unannounce(user, object)
	assert object.data["announcement_count"] == 0

	assert activity == announce_activity

	assert unannounce_activity.data["to"] == [
	User.ap_followers(user),
	announce_activity.data["actor"]
	]

	assert unannounce_activity.data["type"] == "Undo"
	assert unannounce_activity.data["object"] == announce_activity.data
	assert unannounce_activity.data["actor"] == user.ap_id
	assert unannounce_activity.data["context"] == announce_activity.data["context"]

	assert Repo.get(Activity, announce_activity.id) == nil
	end
	end

	describe "uploading files" do
	test "copies the file to the configured folder" do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	"img" => data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = Repo.get_by(User, ap_id: activity.data["actor"])
	followed = Repo.get_by(User, ap_id: activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "fetching an object" do
	test "it fetches an object" do
	{:ok, object} =
	ActivityPub.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

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

	{:ok, object_again} =
	ActivityPub.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert [attachment] = object.data["attachment"]
	assert is_list(attachment["url"])

	assert object == object_again
	end

	test "it works with objects only available via Ostatus" do
	{:ok, object} = ActivityPub.fetch_object_from_id("https://shitposter.club/notice/2827873")
	assert activity = Activity.get_create_activity_by_object_ap_id(object.data["id"])
	assert activity.data["id"]

	{:ok, object_again} =
	ActivityPub.fetch_object_from_id("https://shitposter.club/notice/2827873")

	assert object == object_again
	end

	test "it correctly stitches up conversations between ostatus and ap" do
	last = "https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	{:ok, object} = ActivityPub.fetch_object_from_id(last)

	object = Object.get_by_ap_id(object.data["inReplyTo"])
	assert object
	end
	end

	describe "following / unfollowing" do
	test "creates a follow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, activity} = ActivityPub.follow(follower, followed)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id
	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

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

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id
	- assert activity.data["object"] == follow_activity.data["id"]
	+
	+ assert is_map(activity.data["object"])
	+ assert activity.data["object"]["type"] == "Follow"
	+ assert activity.data["object"]["object"] == followed.ap_id
	+ assert activity.data["object"]["id"] == follow_activity.data["id"]
	+ end
	+ end
	+
	+ describe "blocking / unblocking" do
	+ test "creates a block activity" do
	+ blocker = insert(:user)
	+ blocked = insert(:user)
	+
	+ {:ok, activity} = ActivityPub.block(blocker, blocked)
	+
	+ assert activity.data["type"] == "Block"
	+ assert activity.data["actor"] == blocker.ap_id
	+ assert activity.data["object"] == blocked.ap_id
	+ end
	+
	+ test "creates an undo activity for the last block" do
	+ blocker = insert(:user)
	+ blocked = insert(:user)
	+
	+ {:ok, block_activity} = ActivityPub.block(blocker, blocked)
	+ {:ok, activity} = ActivityPub.unblock(blocker, blocked)
	+
	+ assert activity.data["type"] == "Undo"
	+ assert activity.data["actor"] == blocker.ap_id
	+
	+ assert is_map(activity.data["object"])
	+ assert activity.data["object"]["type"] == "Block"
	+ assert activity.data["object"]["object"] == blocked.ap_id
	+ assert activity.data["object"]["id"] == block_activity.data["id"]
	end
	end

	describe "deletion" do
	test "it creates a delete activity and deletes the original object" do
	note = insert(:note_activity)
	object = Object.get_by_ap_id(note.data["object"]["id"])
	{:ok, delete} = ActivityPub.delete(object)

	assert delete.data["type"] == "Delete"
	assert delete.data["actor"] == note.data["actor"]
	assert delete.data["object"] == note.data["object"]["id"]

	assert Repo.get(Activity, delete.id) != nil

	assert Repo.get(Object, object.id) == nil
	end
	end

	describe "update" do
	test "it creates an update activity with the new user data" do
	user = insert(:user)
	{:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})

	{:ok, update} =
	ActivityPub.update(%{
	actor: user_data["id"],
	to: [user.follower_address],
	cc: [],
	object: user_data
	})

	assert update.data["actor"] == user.ap_id
	assert update.data["to"] == [user.follower_address]
	assert update.data["object"]["id"] == user_data["id"]
	assert update.data["object"]["type"] == user_data["type"]
	end
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end
	end
	diff --git a/test/web/activity_pub/transmogrifier_test.exs b/test/web/activity_pub/transmogrifier_test.exs
	index a0af75a69..cf6b1d0b5 100644
	--- a/test/web/activity_pub/transmogrifier_test.exs
	+++ b/test/web/activity_pub/transmogrifier_test.exs
	@@ -1,489 +1,559 @@
	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Pleroma.DataCase
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.OStatus
	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Repo
	alias Pleroma.Web.Websub.WebsubClientSubscription
	alias Pleroma.Web.Websub.WebsubServerSubscription
	import Ecto.Query

	import Pleroma.Factory
	alias Pleroma.Web.CommonAPI

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

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

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

	assert activity == returned_activity
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert object["sensitive"] == true

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

	assert user.info["note_count"] == 1
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert data["object"]["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
	end
	+
	+ test "it works for incomming unfollows with an existing follow" do
	+ user = insert(:user)
	+
	+ follow_data =
	+ File.read!("test/fixtures/mastodon-follow-activity.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("object", user.ap_id)
	+
	+ {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-unfollow-activity.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("object", follow_data)
	+
	+ {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+
	+ assert data["type"] == "Undo"
	+ assert data["object"]["type"] == "Follow"
	+ assert data["object"]["object"] == user.ap_id
	+ assert data["actor"] == "http://mastodon.example.org/users/admin"
	+
	+ refute User.following?(User.get_by_ap_id(data["actor"]), user)
	+ end
	+
	+ test "it works for incoming blocks" do
	+ user = insert(:user)
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-block-activity.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("object", user.ap_id)
	+
	+ {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+
	+ assert data["type"] == "Block"
	+ assert data["object"] == user.ap_id
	+ assert data["actor"] == "http://mastodon.example.org/users/admin"
	+
	+ blocker = User.get_by_ap_id(data["actor"])
	+
	+ assert User.blocks?(blocker, user)
	+ end
	+
	+ test "it works for incoming unblocks with an existing block" do
	+ user = insert(:user)
	+
	+ block_data =
	+ File.read!("test/fixtures/mastodon-block-activity.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("object", user.ap_id)
	+
	+ {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-unblock-activity.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("object", block_data)
	+
	+ {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+ assert data["type"] == "Undo"
	+ assert data["object"]["type"] == "Block"
	+ assert data["object"]["object"] == user.ap_id
	+ assert data["actor"] == "http://mastodon.example.org/users/admin"
	+
	+ blocker = User.get_by_ap_id(data["actor"])
	+
	+ refute User.blocks?(blocker, user)
	+ end
	end

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

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

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

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

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

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

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

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

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

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

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

	assert modified["@context"] == "https://www.w3.org/ns/activitystreams"
	assert modified["object"]["conversation"] == modified["context"]
	end

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

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

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

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

	user = insert(:user)

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

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

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

	user = insert(:user)

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

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

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

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

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

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

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

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

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

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

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

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

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

	refute "..." in activity.recipients

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

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

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

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

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

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

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

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end
	end
	diff --git a/test/web/ostatus/ostatus_test.exs b/test/web/ostatus/ostatus_test.exs
	index 3e7cf0155..f095e41dd 100644
	--- a/test/web/ostatus/ostatus_test.exs
	+++ b/test/web/ostatus/ostatus_test.exs
	@@ -1,435 +1,459 @@
	defmodule Pleroma.Web.OStatusTest do
	use Pleroma.DataCase
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.XML
	alias Pleroma.{Object, Repo, User, Activity}
	import Pleroma.Factory
	import ExUnit.CaptureLog

	test "don't insert create notes twice" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	assert {:ok, [activity]} == OStatus.handle_incoming(incoming)
	end

	test "handle incoming note - GS, Salmon" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	user = User.get_by_ap_id(activity.data["actor"])
	assert user.info["note_count"] == 1
	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"

	assert activity.data["object"]["id"] ==
	"tag:gs.example.org:4040,2017-04-23:noticeId=29:objectType=note"

	assert activity.data["published"] == "2017-04-23T14:51:03+00:00"
	assert activity.data["object"]["published"] == "2017-04-23T14:51:03+00:00"

	assert activity.data["context"] ==
	"tag:gs.example.org:4040,2017-04-23:objectType=thread:nonce=f09e22f58abd5c7b"

	assert "http://pleroma.example.org:4000/users/lain3" in activity.data["to"]
	assert activity.data["object"]["emoji"] == %{"marko" => "marko.png", "reimu" => "reimu.png"}
	assert activity.local == false
	end

	test "handle incoming notes - GS, subscription" do
	incoming = File.read!("test/fixtures/ostatus_incoming_post.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"]["content"] == "Will it blend?"
	user = User.get_cached_by_ap_id(activity.data["actor"])
	assert User.ap_followers(user) in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes with attachments - GS, subscription" do
	incoming = File.read!("test/fixtures/incoming_websub_gnusocial_attachments.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"]["attachment"] \|> length == 2
	assert activity.data["object"]["external_url"] == "https://social.heldscal.la/notice/2020923"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes with tags" do
	incoming = File.read!("test/fixtures/ostatus_incoming_post_tag.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["object"]["tag"] == ["nsfw"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes - Mastodon, salmon, reply" do
	# It uses the context of the replied to object
	Repo.insert!(%Object{
	data: %{
	"id" => "https://pleroma.soykaf.com/objects/c237d966-ac75-4fe3-a87a-d89d71a3a7a4",
	"context" => "2hu"
	}
	})

	incoming = File.read!("test/fixtures/incoming_reply_mastodon.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["context"] == "2hu"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes - Mastodon, with CW" do
	incoming = File.read!("test/fixtures/mastodon-note-cw.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["object"]["summary"] == "technologic"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming unlisted messages, put public into cc" do
	incoming = File.read!("test/fixtures/mastodon-note-unlisted.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	refute "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["cc"]
	refute "https://www.w3.org/ns/activitystreams#Public" in activity.data["object"]["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["object"]["cc"]
	end

	test "handle incoming retweets - Mastodon, with CW" do
	incoming = File.read!("test/fixtures/cw_retweet.xml")
	{:ok, [[_activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert retweeted_activity.data["object"]["summary"] == "Hey."
	end

	test "handle incoming notes - GS, subscription, reply" do
	incoming = File.read!("test/fixtures/ostatus_incoming_reply.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"

	assert activity.data["object"]["content"] ==
	"@<a href=\"https://gs.archae.me/user/4687\" class=\"h-card u-url p-nickname mention\" title=\"shpbot\">shpbot</a> why not indeed."

	assert activity.data["object"]["inReplyTo"] ==
	"tag:gs.archae.me,2017-04-30:noticeId=778260:objectType=note"

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

	test "handle incoming retweets - GS, subscription" do
	incoming = File.read!("test/fixtures/share-gs.xml")
	{:ok, [[activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]
	assert "https://pleroma.soykaf.com/users/lain" in activity.data["to"]
	refute activity.local

	retweeted_activity = Repo.get(Activity, retweeted_activity.id)
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == "https://pleroma.soykaf.com/users/lain"
	refute retweeted_activity.local
	assert retweeted_activity.data["object"]["announcement_count"] == 1
	assert String.contains?(retweeted_activity.data["object"]["content"], "mastodon")
	refute String.contains?(retweeted_activity.data["object"]["content"], "Test account")
	end

	test "handle incoming retweets - GS, subscription - local message" do
	incoming = File.read!("test/fixtures/share-gs-local.xml")
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	incoming =
	incoming
	\|> String.replace("LOCAL_ID", note_activity.data["object"]["id"])
	\|> String.replace("LOCAL_USER", user.ap_id)

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

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]
	assert user.ap_id in activity.data["to"]
	refute activity.local

	retweeted_activity = Repo.get(Activity, retweeted_activity.id)
	assert note_activity.id == retweeted_activity.id
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == user.ap_id
	assert retweeted_activity.local
	assert retweeted_activity.data["object"]["announcement_count"] == 1
	end

	test "handle incoming retweets - Mastodon, salmon" do
	incoming = File.read!("test/fixtures/share.xml")
	{:ok, [[activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]

	assert activity.data["id"] ==
	"tag:mastodon.social,2017-05-03:objectId=4934452:objectType=Status"

	refute activity.local
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == "https://pleroma.soykaf.com/users/lain"
	refute retweeted_activity.local
	refute String.contains?(retweeted_activity.data["object"]["content"], "Test account")
	end

	test "handle incoming favorites - GS, websub" do
	capture_log(fn ->
	incoming = File.read!("test/fixtures/favorite.xml")
	{:ok, [[activity, favorited_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Like"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == favorited_activity.data["object"]["id"]

	assert activity.data["id"] ==
	"tag:social.heldscal.la,2017-05-05:fave:23211:comment:2061643:2017-05-05T09:12:50+00:00"

	refute activity.local
	assert favorited_activity.data["type"] == "Create"
	assert favorited_activity.data["actor"] == "https://shitposter.club/user/1"

	assert favorited_activity.data["object"]["id"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"

	refute favorited_activity.local
	end)
	end

	test "handle conversation references" do
	incoming = File.read!("test/fixtures/mastodon_conversation.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["context"] ==
	"tag:mastodon.social,2017-08-28:objectId=7876885:objectType=Conversation"
	end

	test "handle incoming favorites with locally available object - GS, websub" do
	note_activity = insert(:note_activity)

	incoming =
	File.read!("test/fixtures/favorite_with_local_note.xml")
	\|> String.replace("localid", note_activity.data["object"]["id"])

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

	assert activity.data["type"] == "Like"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == favorited_activity.data["object"]["id"]
	refute activity.local
	assert note_activity.id == favorited_activity.id
	assert favorited_activity.local
	end

	test "handle incoming replies" do
	incoming = File.read!("test/fixtures/incoming_note_activity_answer.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"

	assert activity.data["object"]["inReplyTo"] ==
	"http://pleroma.example.org:4000/objects/55bce8fc-b423-46b1-af71-3759ab4670bc"

	assert "http://pleroma.example.org:4000/users/lain5" in activity.data["to"]

	assert activity.data["object"]["id"] ==
	"tag:gs.example.org:4040,2017-04-25:noticeId=55:objectType=note"

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

	test "handle incoming follows" do
	incoming = File.read!("test/fixtures/follow.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	assert activity.data["type"] == "Follow"

	assert activity.data["id"] ==
	"tag:social.heldscal.la,2017-05-07:subscription:23211:person:44803:2017-05-07T09:54:48+00:00"

	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == "https://pawoo.net/users/pekorino"
	refute activity.local

	follower = User.get_by_ap_id(activity.data["actor"])
	followed = User.get_by_ap_id(activity.data["object"])

	assert User.following?(follower, followed)
	end

	+ test "handle incoming unfollows with existing follow" do
	+ incoming_follow = File.read!("test/fixtures/follow.xml")
	+ {:ok, [_activity]} = OStatus.handle_incoming(incoming_follow)
	+
	+ incoming = File.read!("test/fixtures/unfollow.xml")
	+ {:ok, [activity]} = OStatus.handle_incoming(incoming)
	+
	+ assert activity.data["type"] == "Undo"
	+
	+ assert activity.data["id"] ==
	+ "undo:tag:social.heldscal.la,2017-05-07:subscription:23211:person:44803:2017-05-07T09:54:48+00:00"
	+
	+ assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	+ assert is_map(activity.data["object"])
	+ assert activity.data["object"]["type"] == "Follow"
	+ assert activity.data["object"]["object"] == "https://pawoo.net/users/pekorino"
	+ refute activity.local
	+
	+ follower = User.get_by_ap_id(activity.data["actor"])
	+ followed = User.get_by_ap_id(activity.data["object"]["object"])
	+
	+ refute User.following?(follower, followed)
	+ end
	+
	describe "new remote user creation" do
	test "returns local users" do
	local_user = insert(:user)
	{:ok, user} = OStatus.find_or_make_user(local_user.ap_id)

	assert user == local_user
	end

	test "tries to use the information in poco fields" do
	uri = "https://social.heldscal.la/user/23211"

	{:ok, user} = OStatus.find_or_make_user(uri)

	user = Repo.get(Pleroma.User, user.id)
	assert user.name == "Constance Variable"
	assert user.nickname == "lambadalambda@social.heldscal.la"
	assert user.local == false
	assert user.info["uri"] == uri
	assert user.ap_id == uri
	assert user.bio == "Call me Deacon Blues."
	assert user.avatar["type"] == "Image"

	{:ok, user_again} = OStatus.find_or_make_user(uri)

	assert user == user_again
	end

	test "find_make_or_update_user takes an author element and returns an updated user" do
	uri = "https://social.heldscal.la/user/23211"

	{:ok, user} = OStatus.find_or_make_user(uri)
	old_name = user.name
	old_bio = user.bio
	change = Ecto.Changeset.change(user, %{avatar: nil, bio: nil, old_name: nil})

	{:ok, user} = Repo.update(change)
	refute user.avatar

	doc = XML.parse_document(File.read!("test/fixtures/23211.atom"))
	[author] = :xmerl_xpath.string('//author[1]', doc)
	{:ok, user} = OStatus.find_make_or_update_user(author)
	assert user.avatar["type"] == "Image"
	assert user.name == old_name
	assert user.bio == old_bio

	{:ok, user_again} = OStatus.find_make_or_update_user(author)
	assert user_again == user
	end
	end

	describe "gathering user info from a user id" do
	test "it returns user info in a hash" do
	user = "shp@social.heldscal.la"

	# TODO: make test local
	{:ok, data} = OStatus.gather_user_info(user)

	expected = %{
	"hub" => "https://social.heldscal.la/main/push/hub",
	"magic_key" =>
	"RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	"name" => "shp",
	"nickname" => "shp",
	"salmon" => "https://social.heldscal.la/main/salmon/user/29191",
	"subject" => "acct:shp@social.heldscal.la",
	"topic" => "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	"uri" => "https://social.heldscal.la/user/29191",
	"host" => "social.heldscal.la",
	"fqn" => user,
	"bio" => "cofe",
	"avatar" => %{
	"type" => "Image",
	"url" => [
	%{
	"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg",
	"mediaType" => "image/jpeg",
	"type" => "Link"
	}
	]
	},
	"subscribe_address" => "https://social.heldscal.la/main/ostatussub?profile={uri}",
	"ap_id" => nil
	}

	assert data == expected
	end

	test "it works with the uri" do
	user = "https://social.heldscal.la/user/29191"

	# TODO: make test local
	{:ok, data} = OStatus.gather_user_info(user)

	expected = %{
	"hub" => "https://social.heldscal.la/main/push/hub",
	"magic_key" =>
	"RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	"name" => "shp",
	"nickname" => "shp",
	"salmon" => "https://social.heldscal.la/main/salmon/user/29191",
	"subject" => "https://social.heldscal.la/user/29191",
	"topic" => "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	"uri" => "https://social.heldscal.la/user/29191",
	"host" => "social.heldscal.la",
	"fqn" => user,
	"bio" => "cofe",
	"avatar" => %{
	"type" => "Image",
	"url" => [
	%{
	"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg",
	"mediaType" => "image/jpeg",
	"type" => "Link"
	}
	]
	},
	"subscribe_address" => "https://social.heldscal.la/main/ostatussub?profile={uri}",
	"ap_id" => nil
	}

	assert data == expected
	end
	end

	describe "fetching a status by it's HTML url" do
	test "it builds a missing status from an html url" do
	capture_log(fn ->
	url = "https://shitposter.club/notice/2827873"
	{:ok, [activity]} = OStatus.fetch_activity_from_url(url)

	assert activity.data["actor"] == "https://shitposter.club/user/1"

	assert activity.data["object"]["id"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	end)
	end

	test "it works for atom notes, too" do
	url = "https://social.sakamoto.gq/objects/0ccc1a2c-66b0-4305-b23a-7f7f2b040056"
	{:ok, [activity]} = OStatus.fetch_activity_from_url(url)
	assert activity.data["actor"] == "https://social.sakamoto.gq/users/eal"
	assert activity.data["object"]["id"] == url
	end
	end

	test "it doesn't add nil in the do field" do
	incoming = File.read!("test/fixtures/nil_mention_entry.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["to"] == [
	"http://localhost:4001/users/atarifrosch@social.stopwatchingus-heidelberg.de/followers",
	"https://www.w3.org/ns/activitystreams#Public"
	]
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_controller_test.exs b/test/web/twitter_api/twitter_api_controller_test.exs
	index 73443e053..c2ea41aa3 100644
	--- a/test/web/twitter_api/twitter_api_controller_test.exs
	+++ b/test/web/twitter_api/twitter_api_controller_test.exs
	@@ -1,907 +1,907 @@
	defmodule Pleroma.Web.TwitterAPI.ControllerTest do
	use Pleroma.Web.ConnCase
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	alias Pleroma.Builders.{ActivityBuilder, UserBuilder}
	alias Pleroma.{Repo, Activity, User, Object, Notification}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.NotificationView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Comeonin.Pbkdf2

	import Pleroma.Factory

	describe "POST /api/account/verify_credentials" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/account/verify_credentials.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	conn =
	conn
	\|> with_credentials(user.nickname, "test")
	\|> post("/api/account/verify_credentials.json")

	assert response = json_response(conn, 200)
	assert response == UserView.render("show.json", %{user: user, token: response["token"]})
	end
	end

	describe "POST /api/account/most_recent_notification" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/account/most_recent_notification.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	conn =
	conn
	\|> with_credentials(user.nickname, "test")
	\|> post("/api/account/most_recent_notification.json", %{id: "200"})

	assert json_response(conn, 200)
	user = User.get_by_nickname(user.nickname)
	assert user.info["most_recent_notification"] == 200
	end
	end

	describe "POST /statuses/update.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/statuses/update.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	conn_with_creds = conn \|> with_credentials(user.nickname, "test")
	request_path = "/api/statuses/update.json"

	error_response = %{
	"request" => request_path,
	"error" => "Client must provide a 'status' parameter with a value."
	}

	conn = conn_with_creds \|> post(request_path)
	assert json_response(conn, 400) == error_response

	conn = conn_with_creds \|> post(request_path, %{status: ""})
	assert json_response(conn, 400) == error_response

	conn = conn_with_creds \|> post(request_path, %{status: " "})
	assert json_response(conn, 400) == error_response

	conn = conn_with_creds \|> post(request_path, %{status: "Nice meme."})

	assert json_response(conn, 200) ==
	ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
	end
	end

	describe "GET /statuses/public_timeline.json" do
	test "returns statuses", %{conn: conn} do
	{:ok, user} = UserBuilder.insert()
	activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
	ActivityBuilder.insert_list(10, %{}, %{user: user})
	since_id = List.last(activities).id

	conn =
	conn
	\|> get("/api/statuses/public_timeline.json", %{since_id: since_id})

	response = json_response(conn, 200)

	assert length(response) == 10
	end
	end

	describe "GET /statuses/show/:id.json" do
	test "returns one status", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
	actor = Repo.get_by!(User, ap_id: activity.data["actor"])

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

	response = json_response(conn, 200)

	assert response == ActivityRepresenter.to_map(activity, %{user: actor})
	end
	end

	describe "GET /users/show.json" do
	test "gets user with screen_name", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/users/show.json", %{"screen_name" => user.nickname})

	response = json_response(conn, 200)

	assert response["id"] == user.id
	end

	test "gets user with user_id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/users/show.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert response["id"] == user.id
	end

	test "gets a user for a logged in user", %{conn: conn} do
	user = insert(:user)
	logged_in = insert(:user)

	{:ok, logged_in, user, _activity} = TwitterAPI.follow(logged_in, %{"user_id" => user.id})

	conn =
	conn
	\|> with_credentials(logged_in.nickname, "test")
	\|> get("/api/users/show.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert response["following"] == true
	end
	end

	describe "GET /statusnet/conversation/:id.json" do
	test "returns the statuses in the conversation", %{conn: conn} do
	{:ok, _user} = UserBuilder.insert()
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})

	conn =
	conn
	\|> get("/api/statusnet/conversation/#{activity.data["context_id"]}.json")

	response = json_response(conn, 200)

	assert length(response) == 2
	end
	end

	describe "GET /statuses/friends_timeline.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/statuses/friends_timeline.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	user = insert(:user)

	activities =
	ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})

	returned_activities =
	ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})

	other_user = insert(:user)
	ActivityBuilder.insert_list(10, %{}, %{user: other_user})
	since_id = List.last(activities).id

	current_user =
	Ecto.Changeset.change(current_user, following: [User.ap_followers(user)])
	\|> Repo.update!()

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/friends_timeline.json", %{since_id: since_id})

	response = json_response(conn, 200)

	assert length(response) == 10

	assert response ==
	Enum.map(returned_activities, fn activity ->
	ActivityRepresenter.to_map(activity, %{
	user: User.get_cached_by_ap_id(activity.data["actor"]),
	for: current_user
	})
	end)
	end
	end

	describe "GET /statuses/mentions.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/statuses/mentions.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	{:ok, activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/mentions.json")

	response = json_response(conn, 200)

	assert length(response) == 1

	assert Enum.at(response, 0) ==
	ActivityRepresenter.to_map(activity, %{
	user: current_user,
	mentioned: [current_user]
	})
	end
	end

	describe "GET /api/qvitter/statuses/notifications.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/qvitter/statuses/notifications.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	other_user = insert(:user)

	{:ok, activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/statuses/notifications.json")

	response = json_response(conn, 200)

	assert length(response) == 1

	assert response ==
	NotificationView.render("notification.json", %{
	notifications: Notification.for_user(current_user),
	for: current_user
	})
	end
	end

	describe "GET /statuses/user_timeline.json" do
	setup [:valid_user]

	test "without any params", %{conn: conn} do
	conn = get(conn, "/api/statuses/user_timeline.json")

	assert json_response(conn, 400) == %{
	"error" => "You need to specify screen_name or user_id",
	"request" => "/api/statuses/user_timeline.json"
	}
	end

	test "with user_id", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
	response = json_response(conn, 200)
	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with screen_name", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
	response = json_response(conn, 200)
	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with credentials", %{conn: conn, user: current_user} do
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json")

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
	end

	test "with credentials with user_id", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with credentials screen_name", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end
	end

	describe "POST /friendships/create.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/friendships/create.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	followed = insert(:user)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/friendships/create.json", %{user_id: followed.id})

	current_user = Repo.get(User, current_user.id)
	assert User.ap_followers(followed) in current_user.following

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

	describe "POST /friendships/destroy.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/friendships/destroy.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	followed = insert(:user)

	{:ok, current_user} = User.follow(current_user, followed)
	assert User.ap_followers(followed) in current_user.following
	ActivityPub.follow(current_user, followed)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/friendships/destroy.json", %{user_id: followed.id})

	current_user = Repo.get(User, current_user.id)
	assert current_user.following == [current_user.ap_id]

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

	describe "POST /blocks/create.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/blocks/create.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	blocked = insert(:user)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/blocks/create.json", %{user_id: blocked.id})

	current_user = Repo.get(User, current_user.id)
	assert User.blocks?(current_user, blocked)

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

	describe "POST /blocks/destroy.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/blocks/destroy.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	blocked = insert(:user)

	- {:ok, current_user} = User.block(current_user, blocked)
	+ {:ok, current_user, blocked} = TwitterAPI.block(current_user, %{"user_id" => blocked.id})
	assert User.blocks?(current_user, blocked)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/blocks/destroy.json", %{user_id: blocked.id})

	current_user = Repo.get(User, current_user.id)
	assert current_user.info["blocks"] == []

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

	describe "GET /help/test.json" do
	test "returns \"ok\"", %{conn: conn} do
	conn = get(conn, "/api/help/test.json")
	assert json_response(conn, 200) == "ok"
	end
	end

	describe "POST /api/qvitter/update_avatar.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/qvitter/update_avatar.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	avatar_image = File.read!("test/fixtures/avatar_data_uri")

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/update_avatar.json", %{img: avatar_image})

	current_user = Repo.get(User, current_user.id)
	assert is_map(current_user.avatar)

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

	describe "POST /api/favorites/create/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/#{note_activity.id}.json")

	assert json_response(conn, 200)
	end
	end

	describe "POST /api/favorites/destroy/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	ActivityPub.like(current_user, object)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/destroy/#{note_activity.id}.json")

	assert json_response(conn, 200)
	end
	end

	describe "POST /api/statuses/retweet/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	request_path = "/api/statuses/retweet/#{note_activity.id}.json"

	response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)

	activity = Repo.get(Activity, note_activity.id)
	activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])

	assert json_response(response, 200) ==
	ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
	end
	end

	describe "POST /api/account/register" do
	test "it creates a new user", %{conn: conn} do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear",
	"confirm" => "bear"
	}

	conn =
	conn
	\|> post("/api/account/register", data)

	user = json_response(conn, 200)

	fetched_user = Repo.get_by(User, nickname: "lain")
	assert user == UserView.render("show.json", %{user: fetched_user})
	end

	test "it returns errors on a problem", %{conn: conn} do
	data = %{
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear",
	"confirm" => "bear"
	}

	conn =
	conn
	\|> post("/api/account/register", data)

	errors = json_response(conn, 400)

	assert is_binary(errors["error"])
	end
	end

	describe "GET /api/externalprofile/show" do
	test "it returns the user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})

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

	describe "GET /api/statuses/followers" do
	test "it returns a user's followers", %{conn: conn} do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	_not_follower = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/followers")

	expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
	result = json_response(conn, 200)
	assert Enum.sort(expected) == Enum.sort(result)
	end
	end

	describe "GET /api/statuses/friends" do
	test "it returns the logged in user's friends", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends")

	expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	result = json_response(conn, 200)
	assert Enum.sort(expected) == Enum.sort(result)
	end

	test "it returns a given user's friends with user_id", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

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

	conn =
	conn
	\|> get("/api/statuses/friends", %{"user_id" => user.id})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	)
	)
	end

	test "it returns a given user's friends with screen_name", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

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

	conn =
	conn
	\|> get("/api/statuses/friends", %{"screen_name" => user.nickname})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	)
	)
	end
	end

	describe "GET /friends/ids" do
	test "it returns a user's friends", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/friends/ids")

	expected = [followed_one.id, followed_two.id]

	assert MapSet.equal?(
	MapSet.new(Poison.decode!(json_response(conn, 200))),
	MapSet.new(expected)
	)
	end
	end

	describe "POST /api/account/update_profile.json" do
	test "it updates a user's profile", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"name" => "new name",
	"description" => "new description"
	})

	user = Repo.get!(User, user.id)
	assert user.name == "new name"
	assert user.bio == "new description"

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

	defp valid_user(_context) do
	user = insert(:user)
	[user: user]
	end

	defp with_credentials(conn, username, password) do
	header_content = "Basic " <> Base.encode64("#{username}:#{password}")
	put_req_header(conn, "authorization", header_content)
	end

	describe "GET /api/search.json" do
	test "it returns search results", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})

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

	conn =
	conn
	\|> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})

	assert [status] = json_response(conn, 200)
	assert status["id"] == activity.id
	end
	end

	describe "GET /api/statusnet/tags/timeline/:tag.json" do
	test "it returns the tags timeline", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
	{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})

	conn =
	conn
	\|> get("/api/statusnet/tags/timeline/2hu.json")

	assert [status] = json_response(conn, 200)
	assert status["id"] == activity.id
	end
	end

	test "Convert newlines to <br> in bio", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"description" => "Hello,\r\nWorld! I\n am a test."
	})

	user = Repo.get!(User, user.id)
	assert user.bio == "Hello,<br>World! I<br> am a test."
	end

	describe "POST /api/pleroma/change_password" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/change_password")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "hi",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials, valid password and new password and confirmation not matching", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "notnewpass"
	})

	assert json_response(conn, 200) == %{
	"error" => "New password does not match confirmation."
	}
	end

	test "with credentials, valid password and invalid new password", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "",
	"new_password_confirmation" => ""
	})

	assert json_response(conn, 200) == %{
	"error" => "New password can't be blank."
	}
	end

	test "with credentials, valid password and matching new password and confirmation", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"status" => "success"}
	fetched_user = Repo.get(User, current_user.id)
	assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
	end
	end

	describe "POST /api/pleroma/delete_account" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/delete_account")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/delete_account", %{"password" => "hi"})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials and valid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/delete_account", %{"password" => "test"})

	assert json_response(conn, 200) == %{"status" => "success"}
	end
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index af565c0e5..4716abb84 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,306 +1,306 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView}
	alias Pleroma.{Activity, User, Object, Repo}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.ActivityView

	import Pleroma.Factory

	test "create a status" do
	user = insert(:user)
	_mentioned_user = UserBuilder.insert(%{nickname: "shp", ap_id: "shp"})

	object_data = %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}

	object = Repo.insert!(%Object{data: object_data})

	input = %{
	"status" =>
	"Hello again, @shp.<script></script>\nThis is on another :moominmamma: line. #2hu #epic #phantasmagoric",
	"media_ids" => [object.id]
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)

	expected_text =
	"Hello again, <span><a href='shp'>@<span>shp</span></a></span>.<script></script><br>This is on another :moominmamma: line. <a href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a> <a href='http://localhost:4001/tag/epic' rel='tag'>#epic</a> <a href='http://localhost:4001/tag/phantasmagoric' rel='tag'>#phantasmagoric</a><br><a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"

	assert get_in(activity.data, ["object", "content"]) == expected_text
	assert get_in(activity.data, ["object", "type"]) == "Note"
	assert get_in(activity.data, ["object", "actor"]) == user.ap_id
	assert get_in(activity.data, ["actor"]) == user.ap_id
	assert Enum.member?(get_in(activity.data, ["cc"]), User.ap_followers(user))

	assert Enum.member?(
	get_in(activity.data, ["to"]),
	"https://www.w3.org/ns/activitystreams#Public"
	)

	assert Enum.member?(get_in(activity.data, ["cc"]), "shp")
	assert activity.local == true

	assert %{"moominmamma" => "http://localhost:4001/finmoji/128px/moominmamma-128.png"} =
	activity.data["object"]["emoji"]

	# hashtags
	assert activity.data["object"]["tag"] == ["2hu", "epic", "phantasmagoric"]

	# Add a context
	assert is_binary(get_in(activity.data, ["context"]))
	assert is_binary(get_in(activity.data, ["object", "context"]))

	assert is_list(activity.data["object"]["attachment"])

	assert activity.data["object"] == Object.get_by_ap_id(activity.data["object"]["id"]).data

	user = User.get_by_ap_id(user.ap_id)

	assert user.info["note_count"] == 1
	end

	test "create a status that is a reply" do
	user = insert(:user)

	input = %{
	"status" => "Hello again."
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)

	input = %{
	"status" => "Here's your (you).",
	"in_reply_to_status_id" => activity.id
	}

	{:ok, reply = %Activity{}} = TwitterAPI.create_status(user, input)

	assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])

	assert get_in(reply.data, ["object", "context"]) ==
	get_in(activity.data, ["object", "context"])

	assert get_in(reply.data, ["object", "inReplyTo"]) == get_in(activity.data, ["object", "id"])
	assert get_in(reply.data, ["object", "inReplyToStatusId"]) == activity.id
	end

	test "Follow another user using user_id" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert User.ap_followers(followed) in user.following

	{:error, msg} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Follow another user using screen_name" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} =
	TwitterAPI.follow(user, %{"screen_name" => followed.nickname})

	assert User.ap_followers(followed) in user.following

	followed = User.get_by_ap_id(followed.ap_id)
	assert followed.info["follower_count"] == 1

	{:error, msg} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Unfollow another user using user_id" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert msg == "Not subscribed!"
	end

	test "Unfollow another user using screen_name" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})

	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert msg == "Not subscribed!"
	end

	test "Block another user using user_id" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"user_id" => blocked.id})
	assert User.blocks?(user, blocked)
	end

	test "Block another user using screen_name" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"screen_name" => blocked.nickname})
	assert User.blocks?(user, blocked)
	end

	test "Unblock another user using user_id" do
	unblocked = insert(:user)
	user = insert(:user)
	- User.block(user, unblocked)
	+ {:ok, user, _unblocked} = TwitterAPI.block(user, %{"user_id" => unblocked.id})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"user_id" => unblocked.id})
	assert user.info["blocks"] == []
	end

	test "Unblock another user using screen_name" do
	unblocked = insert(:user)
	user = insert(:user)
	- User.block(user, unblocked)
	+ {:ok, user, _unblocked} = TwitterAPI.block(user, %{"screen_name" => unblocked.nickname})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"screen_name" => unblocked.nickname})
	assert user.info["blocks"] == []
	end

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

	response = TwitterAPI.upload(file)

	assert is_binary(response)
	end

	test "it favorites a status, returns the updated activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.fav(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it unfavorites a status, returns the updated 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)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert ActivityView.render("activity.json", activity: updated_activity)["fave_num"] == 1

	{:ok, activity} = TwitterAPI.unfav(user, note_activity.id)

	assert ActivityView.render("activity.json", activity: activity)["fave_num"] == 0
	end

	test "it retweets a status and returns the retweet" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.repeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it registers a new user and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = Repo.get_by(User, nickname: "lain")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "it returns the error on registration problems" do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear"
	}

	{:error, error_object} = TwitterAPI.register_user(data)

	assert is_binary(error_object[:error])
	refute Repo.get_by(User, nickname: "lain")
	end

	test "it assigns an integer conversation_id" do
	note_activity = insert(:note_activity)
	status = ActivityView.render("activity.json", activity: note_activity)

	assert is_number(status["statusnet_conversation_id"])
	end

	setup do
	Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
	Supervisor.restart_child(Pleroma.Supervisor, Cachex)
	:ok
	end

	describe "context_to_conversation_id" do
	test "creates a mapping object" do
	conversation_id = TwitterAPI.context_to_conversation_id("random context")
	object = Object.get_by_ap_id("random context")

	assert conversation_id == object.id
	end

	test "returns an existing mapping for an existing object" do
	{:ok, object} = Object.context_mapping("random context") \|> Repo.insert()
	conversation_id = TwitterAPI.context_to_conversation_id("random context")

	assert conversation_id == object.id
	end
	end

	describe "fetching a user by uri" do
	test "fetches a user by uri" do
	id = "https://mastodon.social/users/lambadalambda"
	user = insert(:user)
	{:ok, represented} = TwitterAPI.get_external_profile(user, id)
	remote = User.get_by_ap_id(id)

	assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]

	# Also fetches the feed.
	# assert Activity.get_create_activity_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 2:22 AM (16 h, 24 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802233
Default Alt Text: (221 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions