No OneTemporary
Actions

Size

63 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/plugs/http_signature.ex b/lib/pleroma/plugs/http_signature.ex
	index 8b9ccdd2d..efde652f5 100644
	--- a/lib/pleroma/plugs/http_signature.ex
	+++ b/lib/pleroma/plugs/http_signature.ex
	@@ -1,39 +1,39 @@
	defmodule Pleroma.Web.Plugs.HTTPSignaturePlug do
	alias Pleroma.Web.HTTPSignatures
	import Plug.Conn
	require Logger

	def init(options) do
	options
	end

	- def call(%{assigns: %{valid_signature: true}} = conn, opts) do
	+ def call(%{assigns: %{valid_signature: true}} = conn, _opts) do
	conn
	end

	- def call(conn, opts) do
	+ def call(conn, _opts) do
	user = conn.params["actor"]
	Logger.debug("Checking sig for #{user}")
	[signature \| _] = get_req_header(conn, "signature")

	cond do
	signature && String.contains?(signature, user) ->
	conn =
	conn
	\|> put_req_header(
	"(request-target)",
	String.downcase("#{conn.method}") <> " #{conn.request_path}"
	)

	assign(conn, :valid_signature, HTTPSignatures.validate_conn(conn))

	signature ->
	Logger.debug("Signature not from actor")
	assign(conn, :valid_signature, false)

	true ->
	Logger.debug("No signature header!")
	conn
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/simple_policy.ex b/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	index ea1af0f4d..ad28cbfe3 100644
	--- a/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	@@ -1,76 +1,76 @@
	defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicy do
	alias Pleroma.User

	@mrf_policy Application.get_env(:pleroma, :mrf_simple)

	@reject Keyword.get(@mrf_policy, :reject)
	defp check_reject(actor_info, object) do
	if actor_info.host in @reject do
	{:reject, nil}
	else
	{:ok, object}
	end
	end

	@media_removal Keyword.get(@mrf_policy, :media_removal)
	defp check_media_removal(actor_info, object) do
	if actor_info.host in @media_removal do
	child_object = Map.delete(object["object"], "attachment")
	object = Map.put(object, "object", child_object)
	end

	{:ok, object}
	end

	@media_nsfw Keyword.get(@mrf_policy, :media_nsfw)
	defp check_media_nsfw(actor_info, object) do
	child_object = object["object"]

	if actor_info.host in @media_nsfw and child_object["attachment"] != nil and
	length(child_object["attachment"]) > 0 do
	tags = (child_object["tag"] \|\| []) ++ ["nsfw"]
	child_object = Map.put(child_object, "tags", tags)
	child_object = Map.put(child_object, "sensitive", true)
	object = Map.put(object, "object", child_object)
	end

	{:ok, object}
	end

	@ftl_removal Keyword.get(@mrf_policy, :federated_timeline_removal)
	defp check_ftl_removal(actor_info, object) do
	if actor_info.host in @ftl_removal do
	user = User.get_by_ap_id(object["actor"])

	# flip to/cc relationship to make the post unlisted
	if "https://www.w3.org/ns/activitystreams#Public" in object["to"] and
	user.follower_address in object["cc"] do
	to =
	List.delete(object["to"], "https://www.w3.org/ns/activitystreams#Public") ++
	[user.follower_address]

	cc =
	List.delete(object["cc"], user.follower_address) ++
	["https://www.w3.org/ns/activitystreams#Public"]

	object = Map.put(object, "to", to)
	object = Map.put(object, "cc", cc)
	end
	end

	{:ok, object}
	end

	def filter(object) do
	actor_info = URI.parse(object["actor"])

	with {:ok, object} <- check_reject(actor_info, object),
	{:ok, object} <- check_media_removal(actor_info, object),
	{:ok, object} <- check_media_nsfw(actor_info, object),
	{:ok, object} <- check_ftl_removal(actor_info, object) do
	{:ok, object}
	else
	- e -> {:reject, nil}
	+ _e -> {:reject, nil}
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index 2871a2544..221bc7dab 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,477 +1,477 @@
	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"]

	if String.starts_with?(name, ":") do
	name = name \|> String.slice(1..-2)
	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
	+ %{"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, _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

	# TODO
	# Accept
	# Undo

	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
	end
	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index 3c092d524..b142eda95 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,187 +1,187 @@
	defmodule Pleroma.Web.CommonAPI.Utils do
	alias Pleroma.{Repo, Object, Formatter, User, Activity}
	alias Pleroma.Web.ActivityPub.Utils
	alias Calendar.Strftime

	# This is a hack for twidere.
	def get_by_id_or_ap_id(id) do
	activity = Repo.get(Activity, id) \|\| Activity.get_create_activity_by_object_ap_id(id)

	if activity.data["type"] == "Create" do
	activity
	else
	Activity.get_create_activity_by_object_ap_id(activity.data["object"])
	end
	end

	def get_replied_to_activity(id) when not is_nil(id) do
	Repo.get(Activity, id)
	end

	def get_replied_to_activity(_), do: nil

	def attachments_from_ids(ids) do
	Enum.map(ids \|\| [], fn media_id ->
	Repo.get(Object, media_id).data
	end)
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "public") do
	to = ["https://www.w3.org/ns/activitystreams#Public"]

	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)
	cc = [user.follower_address \| mentioned_users]

	if inReplyTo do
	{to, Enum.uniq([inReplyTo.data["actor"] \| cc])}
	else
	{to, cc}
	end
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "unlisted") do
	{to, cc} = to_for_user_and_mentions(user, mentions, inReplyTo, "public")
	{cc, to}
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "private") do
	{to, cc} = to_for_user_and_mentions(user, mentions, inReplyTo, "direct")
	{[user.follower_address \| to], cc}
	end

	- def to_for_user_and_mentions(user, mentions, inReplyTo, "direct") do
	+ def to_for_user_and_mentions(_user, mentions, inReplyTo, "direct") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| mentioned_users]), []}
	else
	{mentioned_users, []}
	end
	end

	def make_content_html(status, mentions, attachments, tags, no_attachment_links \\ false) do
	status
	\|> String.replace("\r", "")
	\|> format_input(mentions, tags)
	\|> maybe_add_attachments(attachments, no_attachment_links)
	end

	def make_context(%Activity{data: %{"context" => context}}), do: context
	def make_context(_), do: Utils.generate_context_id()

	- def maybe_add_attachments(text, attachments, _no_links = true), do: text
	+ def maybe_add_attachments(text, _attachments, _no_links = true), do: text

	def maybe_add_attachments(text, attachments, _no_links) do
	add_attachments(text, attachments)
	end

	def add_attachments(text, attachments) do
	attachment_text =
	Enum.map(attachments, fn
	%{"url" => [%{"href" => href} \| _]} ->
	name = URI.decode(Path.basename(href))
	"<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"

	_ ->
	""
	end)

	Enum.join([text \| attachment_text], "<br>")
	end

	def format_input(text, mentions, tags) do
	text
	\|> Formatter.html_escape()
	\|> String.replace("\n", "<br>")
	\|> (&{[], &1}).()
	\|> Formatter.add_links()
	\|> Formatter.add_user_links(mentions)
	\|> Formatter.add_hashtag_links(tags)
	\|> Formatter.finalize()
	end

	def add_tag_links(text, tags) do
	tags =
	tags
	\|> Enum.sort_by(fn {tag, _} -> -String.length(tag) end)

	Enum.reduce(tags, text, fn {full, tag}, text ->
	url = "#<a href='#{Pleroma.Web.base_url()}/tag/#{tag}' rel='tag'>#{tag}</a>"
	String.replace(text, full, url)
	end)
	end

	def make_note_data(
	actor,
	to,
	context,
	content_html,
	attachments,
	inReplyTo,
	tags,
	cw \\ nil,
	cc \\ []
	) do
	object = %{
	"type" => "Note",
	"to" => to,
	"cc" => cc,
	"content" => content_html,
	"summary" => cw,
	"context" => context,
	"attachment" => attachments,
	"actor" => actor,
	"tag" => tags \|> Enum.map(fn {_, tag} -> tag end)
	}

	if inReplyTo do
	object
	\|> Map.put("inReplyTo", inReplyTo.data["object"]["id"])
	\|> Map.put("inReplyToStatusId", inReplyTo.id)
	else
	object
	end
	end

	def format_naive_asctime(date) do
	date \|> DateTime.from_naive!("Etc/UTC") \|> format_asctime
	end

	def format_asctime(date) do
	Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
	end

	def date_to_asctime(date) do
	with {:ok, date, _offset} <- date \|> DateTime.from_iso8601() do
	format_asctime(date)
	else
	_e ->
	""
	end
	end

	def to_masto_date(%NaiveDateTime{} = date) do
	date
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	end

	def to_masto_date(date) do
	try do
	date
	\|> NaiveDateTime.from_iso8601!()
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	rescue
	_e -> ""
	end
	end

	defp shortname(name) do
	if String.length(name) < 30 do
	name
	else
	String.slice(name, 0..30) <> "…"
	end
	end
	end
	diff --git a/lib/pleroma/web/federator/federator.ex b/lib/pleroma/web/federator/federator.ex
	index 8335add9c..c4c18192c 100644
	--- a/lib/pleroma/web/federator/federator.ex
	+++ b/lib/pleroma/web/federator/federator.ex
	@@ -1,205 +1,205 @@
	defmodule Pleroma.Web.Federator do
	use GenServer
	alias Pleroma.User
	alias Pleroma.Activity
	alias Pleroma.Web.{WebFinger, Websub}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	require Logger

	@websub Application.get_env(:pleroma, :websub)
	@ostatus Application.get_env(:pleroma, :ostatus)
	@httpoison Application.get_env(:pleroma, :httpoison)
	@instance Application.get_env(:pleroma, :instance)
	@federating Keyword.get(@instance, :federating)
	@max_jobs 20

	def start_link do
	spawn(fn ->
	# 1 minute
	Process.sleep(1000 * 60 * 1)
	enqueue(:refresh_subscriptions, nil)
	end)

	GenServer.start_link(
	__MODULE__,
	%{
	in: {:sets.new(), []},
	out: {:sets.new(), []}
	},
	name: __MODULE__
	)
	end

	def handle(:refresh_subscriptions, _) do
	Logger.debug("Federator running refresh subscriptions")
	Websub.refresh_subscriptions()

	spawn(fn ->
	# 6 hours
	Process.sleep(1000 * 60 * 60 * 6)
	enqueue(:refresh_subscriptions, nil)
	end)
	end

	def handle(:request_subscription, websub) do
	Logger.debug("Refreshing #{websub.topic}")

	with {:ok, websub} <- Websub.request_subscription(websub) do
	Logger.debug("Successfully refreshed #{websub.topic}")
	else
	_e -> Logger.debug("Couldn't refresh #{websub.topic}")
	end
	end

	def handle(:publish, activity) do
	Logger.debug(fn -> "Running publish for #{activity.data["id"]}" end)

	with actor when not is_nil(actor) <- User.get_cached_by_ap_id(activity.data["actor"]) do
	{:ok, actor} = WebFinger.ensure_keys_present(actor)

	if ActivityPub.is_public?(activity) do
	Logger.info(fn -> "Sending #{activity.data["id"]} out via WebSub" end)
	Websub.publish(Pleroma.Web.OStatus.feed_path(actor), actor, activity)

	Logger.info(fn -> "Sending #{activity.data["id"]} out via Salmon" end)
	Pleroma.Web.Salmon.publish(actor, activity)
	end

	Logger.info(fn -> "Sending #{activity.data["id"]} out via AP" end)
	Pleroma.Web.ActivityPub.ActivityPub.publish(actor, activity)
	end
	end

	def handle(:verify_websub, websub) do
	Logger.debug(fn ->
	"Running WebSub verification for #{websub.id} (#{websub.topic}, #{websub.callback})"
	end)

	@websub.verify(websub)
	end

	def handle(:incoming_doc, doc) do
	Logger.info("Got document, trying to parse")
	@ostatus.handle_incoming(doc)
	end

	def handle(:incoming_ap_doc, params) do
	Logger.info("Handling incoming AP activity")

	with {:ok, _user} <- ap_enabled_actor(params["actor"]),
	nil <- Activity.get_by_ap_id(params["id"]),
	- {:ok, activity} <- Transmogrifier.handle_incoming(params) do
	+ {:ok, _activity} <- Transmogrifier.handle_incoming(params) do
	else
	%Activity{} ->
	Logger.info("Already had #{params["id"]}")

	- e ->
	+ _e ->
	# Just drop those for now
	Logger.info("Unhandled activity")
	Logger.info(Poison.encode!(params, pretty: 2))
	end
	end

	def handle(:publish_single_ap, params) do
	ActivityPub.publish_one(params)
	end

	def handle(:publish_single_websub, %{xml: xml, topic: topic, callback: callback, secret: secret}) do
	signature = @websub.sign(secret \|\| "", xml)
	Logger.debug(fn -> "Pushing #{topic} to #{callback}" end)

	with {:ok, %{status_code: code}} <-
	@httpoison.post(
	callback,
	xml,
	[
	{"Content-Type", "application/atom+xml"},
	{"X-Hub-Signature", "sha1=#{signature}"}
	],
	timeout: 10000,
	recv_timeout: 20000,
	hackney: [pool: :default]
	) do
	Logger.debug(fn -> "Pushed to #{callback}, code #{code}" end)
	else
	e ->
	Logger.debug(fn -> "Couldn't push to #{callback}, #{inspect(e)}" end)
	end
	end

	def handle(type, _) do
	Logger.debug(fn -> "Unknown task: #{type}" end)
	{:error, "Don't know what to do with this"}
	end

	def enqueue(type, payload, priority \\ 1) do
	if @federating do
	if Mix.env() == :test do
	handle(type, payload)
	else
	GenServer.cast(__MODULE__, {:enqueue, type, payload, priority})
	end
	end
	end

	def maybe_start_job(running_jobs, queue) do
	if :sets.size(running_jobs) < @max_jobs && queue != [] do
	{{type, payload}, queue} = queue_pop(queue)
	{:ok, pid} = Task.start(fn -> handle(type, payload) end)
	mref = Process.monitor(pid)
	{:sets.add_element(mref, running_jobs), queue}
	else
	{running_jobs, queue}
	end
	end

	- def handle_cast({:enqueue, type, payload, priority}, state)
	+ def handle_cast({:enqueue, type, payload, _priority}, state)
	when type in [:incoming_doc, :incoming_ap_doc] do
	%{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}} = state
	i_queue = enqueue_sorted(i_queue, {type, payload}, 1)
	{i_running_jobs, i_queue} = maybe_start_job(i_running_jobs, i_queue)
	{:noreply, %{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}}}
	end

	- def handle_cast({:enqueue, type, payload, priority}, state) do
	+ def handle_cast({:enqueue, type, payload, _priority}, state) do
	%{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}} = state
	o_queue = enqueue_sorted(o_queue, {type, payload}, 1)
	{o_running_jobs, o_queue} = maybe_start_job(o_running_jobs, o_queue)
	{:noreply, %{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}}}
	end

	def handle_cast(m, state) do
	IO.inspect("Unknown: #{inspect(m)}, #{inspect(state)}")
	{:noreply, state}
	end

	def handle_info({:DOWN, ref, :process, _pid, _reason}, state) do
	%{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}} = state
	i_running_jobs = :sets.del_element(ref, i_running_jobs)
	o_running_jobs = :sets.del_element(ref, o_running_jobs)
	{i_running_jobs, i_queue} = maybe_start_job(i_running_jobs, i_queue)
	{o_running_jobs, o_queue} = maybe_start_job(o_running_jobs, o_queue)

	{:noreply, %{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}}}
	end

	def enqueue_sorted(queue, element, priority) do
	[%{item: element, priority: priority} \| queue]
	\|> Enum.sort_by(fn %{priority: priority} -> priority end)
	end

	def queue_pop([%{item: element} \| queue]) do
	{element, queue}
	end

	def ap_enabled_actor(id) do
	user = User.get_by_ap_id(id)

	if User.ap_enabled?(user) do
	{:ok, user}
	else
	ActivityPub.make_user_from_ap_id(id)
	end
	end
	end
	diff --git a/lib/pleroma/web/http_signatures/http_signatures.ex b/lib/pleroma/web/http_signatures/http_signatures.ex
	index 0ea3b7554..9035f5eb6 100644
	--- a/lib/pleroma/web/http_signatures/http_signatures.ex
	+++ b/lib/pleroma/web/http_signatures/http_signatures.ex
	@@ -1,85 +1,85 @@
	# https://tools.ietf.org/html/draft-cavage-http-signatures-08
	defmodule Pleroma.Web.HTTPSignatures do
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	require Logger

	def split_signature(sig) do
	default = %{"headers" => "date"}

	sig =
	sig
	\|> String.trim()
	\|> String.split(",")
	\|> Enum.reduce(default, fn part, acc ->
	[key \| rest] = String.split(part, "=")
	value = Enum.join(rest, "=")
	Map.put(acc, key, String.trim(value, "\""))
	end)

	Map.put(sig, "headers", String.split(sig["headers"], ~r/\s/))
	end

	def validate(headers, signature, public_key) do
	sigstring = build_signing_string(headers, signature["headers"])
	Logger.debug("Signature: #{signature["signature"]}")
	Logger.debug("Sigstring: #{sigstring}")
	{:ok, sig} = Base.decode64(signature["signature"])
	:public_key.verify(sigstring, :sha256, sig, public_key)
	end

	def validate_conn(conn) do
	# TODO: How to get the right key and see if it is actually valid for that request.
	# For now, fetch the key for the actor.
	with actor_id <- conn.params["actor"],
	{:ok, public_key} <- User.get_public_key_for_ap_id(actor_id) do
	if validate_conn(conn, public_key) do
	true
	else
	Logger.debug("Could not validate, re-fetching user and trying one more time")
	# Fetch user anew and try one more time
	with actor_id <- conn.params["actor"],
	{:ok, _user} <- ActivityPub.make_user_from_ap_id(actor_id),
	{:ok, public_key} <- User.get_public_key_for_ap_id(actor_id) do
	validate_conn(conn, public_key)
	end
	end
	else
	- e ->
	+ _e ->
	Logger.debug("Could not public key!")
	false
	end
	end

	def validate_conn(conn, public_key) do
	headers = Enum.into(conn.req_headers, %{})
	signature = split_signature(headers["signature"])
	validate(headers, signature, public_key)
	end

	def build_signing_string(headers, used_headers) do
	used_headers
	\|> Enum.map(fn header -> "#{header}: #{headers[header]}" end)
	\|> Enum.join("\n")
	end

	def sign(user, headers) do
	with {:ok, %{info: %{"keys" => keys}}} <- Pleroma.Web.WebFinger.ensure_keys_present(user),
	{:ok, private_key, _} = Pleroma.Web.Salmon.keys_from_pem(keys) do
	sigstring = build_signing_string(headers, Map.keys(headers))

	signature =
	:public_key.sign(sigstring, :sha256, private_key)
	\|> Base.encode64()

	[
	keyId: user.ap_id <> "#main-key",
	algorithm: "rsa-sha256",
	headers: Map.keys(headers) \|> Enum.join(" "),
	signature: signature
	]
	\|> Enum.map(fn {k, v} -> "#{k}=\"#{v}\"" end)
	\|> Enum.join(",")
	end
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index c12cd7f8a..5a843a3ab 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,261 +1,261 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
	alias Pleroma.{User, Activity, Repo, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	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 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, 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, 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, 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

	def fav(%User{} = user, ap_id_or_id) do
	with {:ok, _announce, %{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, %{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
	+ 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)
	+ _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/lib/pleroma/web/xml/xml.ex b/lib/pleroma/web/xml/xml.ex
	index 8b609f695..36430a3fa 100644
	--- a/lib/pleroma/web/xml/xml.ex
	+++ b/lib/pleroma/web/xml/xml.ex
	@@ -1,37 +1,37 @@
	defmodule Pleroma.Web.XML do
	require Logger

	def string_from_xpath(_, :error), do: nil

	def string_from_xpath(xpath, doc) do
	try do
	{:xmlObj, :string, res} = :xmerl_xpath.string('string(#{xpath})', doc)

	res =
	res
	\|> to_string
	\|> String.trim()

	if res == "", do: nil, else: res
	catch
	- e ->
	+ _e ->
	Logger.debug("Couldn't find xpath #{xpath} in XML doc")
	nil
	end
	end

	def parse_document(text) do
	try do
	{doc, _rest} =
	text
	\|> :binary.bin_to_list()
	\|> :xmerl_scan.string()

	doc
	catch
	:exit, _error ->
	Logger.debug("Couldn't parse XML: #{inspect(text)}")
	:error
	end
	end
	end
	diff --git a/test/support/builders/activity_builder.ex b/test/support/builders/activity_builder.ex
	index d9c188955..eb72d5ba9 100644
	--- a/test/support/builders/activity_builder.ex
	+++ b/test/support/builders/activity_builder.ex
	@@ -1,50 +1,50 @@
	defmodule Pleroma.Builders.ActivityBuilder do
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Web.ActivityPub.ActivityPub

	def build(data \\ %{}, opts \\ %{}) do
	user = opts[:user] \|\| Pleroma.Factory.insert(:user)

	activity = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "test",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}
	}

	Map.merge(activity, data)
	end

	def insert(data \\ %{}, opts \\ %{}) do
	activity = build(data, opts)
	ActivityPub.insert(activity)
	end

	def insert_list(times, data \\ %{}, opts \\ %{}) do
	- Enum.map(1..times, fn n ->
	+ Enum.map(1..times, fn _n ->
	{:ok, activity} = insert(data, opts)
	activity
	end)
	end

	def public_and_non_public do
	user = Pleroma.Factory.insert(:user)

	public = build(%{"id" => 1}, %{user: user})
	non_public = build(%{"id" => 2, "to" => [user.follower_address]}, %{user: user})

	{:ok, public} = ActivityPub.insert(public)
	{:ok, non_public} = ActivityPub.insert(non_public)

	%{
	public: public,
	non_public: non_public,
	user: user
	}
	end
	end
	diff --git a/test/support/httpoison_mock.ex b/test/support/httpoison_mock.ex
	index ba35c4460..4a5a9ea85 100644
	--- a/test/support/httpoison_mock.ex
	+++ b/test/support/httpoison_mock.ex
	@@ -1,721 +1,721 @@
	defmodule HTTPoisonMock do
	alias HTTPoison.Response

	def get(url, body \\ [], headers \\ [])

	def get(
	"http://framatube.org/.well-known/webfinger?resource=acct:framasoft@framatube.org",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/framasoft@framatube.org.json")
	}}
	end

	def get(
	"http://gnusocial.de/.well-known/webfinger?resource=acct:winterdienst@gnusocial.de",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/winterdienst_webfinger.json")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "nonexistant@social.heldscal.la"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 500,
	body: File.read!("test/fixtures/httpoison_mock/nonexistant@social.heldscal.la.xml")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=shp@social.heldscal.la",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/shp@social.heldscal.la.xml")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "shp@social.heldscal.la"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/shp@social.heldscal.la.xml")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "https://social.heldscal.la/user/23211"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___social.heldscal.la_user_23211.xml")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=https://social.heldscal.la/user/23211",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___social.heldscal.la_user_23211.xml")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "https://social.heldscal.la/user/29191"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___social.heldscal.la_user_29191.xml")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=https://social.heldscal.la/user/29191",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___social.heldscal.la_user_29191.xml")
	}}
	end

	def get(
	"https://mastodon.social/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "https://mastodon.social/users/lambadalambda"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___mastodon.social_users_lambadalambda.xml"
	)
	}}
	end

	def get(
	"https://mastodon.social/.well-known/webfinger?resource=https://mastodon.social/users/lambadalambda",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___mastodon.social_users_lambadalambda.xml"
	)
	}}
	end

	def get(
	"https://shitposter.club/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "https://shitposter.club/user/1"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___shitposter.club_user_1.xml")
	}}
	end

	def get(
	"https://shitposter.club/.well-known/webfinger?resource=https://shitposter.club/user/1",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___shitposter.club_user_1.xml")
	}}
	end

	def get(
	"https://shitposter.club/.well-known/webfinger?resource=https://shitposter.club/user/5381",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/spc_5381_xrd.xml")
	}}
	end

	def get(
	"http://gs.example.org/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "http://gs.example.org:4040/index.php/user/1"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/http___gs.example.org_4040_index.php_user_1.xml"
	)
	}}
	end

	def get(
	"http://gs.example.org/.well-known/webfinger?resource=http://gs.example.org:4040/index.php/user/1",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/http___gs.example.org_4040_index.php_user_1.xml"
	)
	}}
	end

	def get(
	"https://social.stopwatchingus-heidelberg.de/.well-known/webfinger?resource=https://social.stopwatchingus-heidelberg.de/user/18330",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/atarifrosch_webfinger.xml")
	}}
	end

	def get(
	"https://pleroma.soykaf.com/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "https://pleroma.soykaf.com/users/lain"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___pleroma.soykaf.com_users_lain.xml")
	}}
	end

	def get(
	"https://pleroma.soykaf.com/.well-known/webfinger?resource=https://pleroma.soykaf.com/users/lain",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___pleroma.soykaf.com_users_lain.xml")
	}}
	end

	def get("https://social.heldscal.la/api/statuses/user_timeline/29191.atom", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___social.heldscal.la_api_statuses_user_timeline_29191.atom.xml"
	)
	}}
	end

	def get("https://shitposter.club/api/statuses/user_timeline/5381.atom", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/spc_5381.atom")
	}}
	end

	def get("https://social.heldscal.la/api/statuses/user_timeline/23211.atom", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___social.heldscal.la_api_statuses_user_timeline_23211.atom.xml"
	)
	}}
	end

	def get("https://mastodon.social/users/lambadalambda.atom", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___mastodon.social_users_lambadalambda.atom"
	)
	}}
	end

	def get(
	"https://social.stopwatchingus-heidelberg.de/api/statuses/user_timeline/18330.atom",
	_body,
	_headers
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/atarifrosch_feed.xml")
	}}
	end

	def get("https://pleroma.soykaf.com/users/lain/feed.atom", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___pleroma.soykaf.com_users_lain_feed.atom.xml"
	)
	}}
	end

	def get("https://social.sakamoto.gq/users/eal/feed.atom", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/sakamoto_eal_feed.atom")
	}}
	end

	def get("http://gs.example.org/index.php/api/statuses/user_timeline/1.atom", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/http__gs.example.org_index.php_api_statuses_user_timeline_1.atom.xml"
	)
	}}
	end

	def get("https://shitposter.club/notice/2827873", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!("test/fixtures/httpoison_mock/https___shitposter.club_notice_2827873.html")
	}}
	end

	def get("https://shitposter.club/api/statuses/show/2827873.atom", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___shitposter.club_api_statuses_show_2827873.atom.xml"
	)
	}}
	end

	def get("https://shitposter.club/api/statuses/user_timeline/1.atom", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___shitposter.club_api_statuses_user_timeline_1.atom.xml"
	)
	}}
	end

	def post(
	"https://social.heldscal.la/main/push/hub",
	- {:form, data},
	+ {:form, _data},
	"Content-type": "application/x-www-form-urlencoded"
	) do
	{:ok,
	%Response{
	status_code: 202
	}}
	end

	def get(
	"https://pawoo.net/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "https://pawoo.net/users/pekorino"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___pawoo.net_users_pekorino.xml")
	}}
	end

	def get(
	"https://pawoo.net/.well-known/webfinger?resource=https://pawoo.net/users/pekorino",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___pawoo.net_users_pekorino.xml")
	}}
	end

	def get("https://pawoo.net/users/pekorino.atom", _, _) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___pawoo.net_users_pekorino.atom")
	}}
	end

	def get(
	"https://mamot.fr/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "https://mamot.fr/users/Skruyb"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/skruyb@mamot.fr.atom")
	}}
	end

	def get(
	"https://mamot.fr/.well-known/webfinger?resource=https://mamot.fr/users/Skruyb",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/skruyb@mamot.fr.atom")
	}}
	end

	def get(
	"https://social.sakamoto.gq/.well-known/webfinger",
	[Accept: "application/xrd+xml,application/jrd+json"],
	params: [resource: "https://social.sakamoto.gq/users/eal"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/eal_sakamoto.xml")
	}}
	end

	def get(
	"https://social.sakamoto.gq/.well-known/webfinger?resource=https://social.sakamoto.gq/users/eal",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/eal_sakamoto.xml")
	}}
	end

	def get(
	"https://pleroma.soykaf.com/.well-known/webfinger?resource=https://pleroma.soykaf.com/users/shp",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/shp@pleroma.soykaf.com.webfigner")
	}}
	end

	def get(
	"https://squeet.me/xrd/?uri=lain@squeet.me",
	[Accept: "application/xrd+xml,application/jrd+json"],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/lain_squeet.me_webfinger.xml")
	}}
	end

	def get("https://mamot.fr/users/Skruyb.atom", _, _) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___mamot.fr_users_Skruyb.atom")
	}}
	end

	def get(
	"https://social.sakamoto.gq/objects/0ccc1a2c-66b0-4305-b23a-7f7f2b040056",
	[Accept: "application/atom+xml"],
	_
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/sakamoto.atom")
	}}
	end

	def get("https://pleroma.soykaf.com/users/shp/feed.atom", _, _) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/shp@pleroma.soykaf.com.feed")
	}}
	end

	def get("http://social.heldscal.la/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/social.heldscal.la_host_meta")
	}}
	end

	def get("http://macgirvin.com/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/macgirvin.com_host_meta")
	}}
	end

	def get("http://mastodon.social/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/mastodon.social_host_meta")
	}}
	end

	def get("http://shitposter.club/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/shitposter.club_host_meta")
	}}
	end

	def get("http://pleroma.soykaf.com/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/pleroma.soykaf.com_host_meta")
	}}
	end

	def get("http://social.sakamoto.gq/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/social.sakamoto.gq_host_meta")
	}}
	end

	def get("http://gs.example.org/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/gs.example.org_host_meta")
	}}
	end

	def get("http://pawoo.net/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/pawoo.net_host_meta")
	}}
	end

	def get("http://mamot.fr/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/mamot.fr_host_meta")
	}}
	end

	def get("http://mastodon.xyz/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/mastodon.xyz_host_meta")
	}}
	end

	def get("http://social.wxcafe.net/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/social.wxcafe.net_host_meta")
	}}
	end

	def get("http://squeet.me/.well-known/host-meta", [], follow_redirect: true) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/squeet.me_host_meta")
	}}
	end

	def get(
	"http://social.stopwatchingus-heidelberg.de/.well-known/host-meta",
	[],
	follow_redirect: true
	) do
	{:ok,
	%Response{
	status_code: 200,
	body:
	File.read!("test/fixtures/httpoison_mock/social.stopwatchingus-heidelberg.de_host_meta")
	}}
	end

	def get("http://mastodon.example.org/users/admin", [Accept: "application/activity+json"], _) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/admin@mastdon.example.org.json")
	}}
	end

	def get("https://masto.quad.moe/users/_HellPie", [Accept: "application/activity+json"], _) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/hellpie.json")
	}}
	end

	def get("https://niu.moe/users/rye", [Accept: "application/activity+json"], _) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/rye.json")
	}}
	end

	def get(
	"https://mst3k.interlinked.me/users/luciferMysticus",
	[Accept: "application/activity+json"],
	_
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/lucifermysticus.json")
	}}
	end

	def get("https://mstdn.io/users/mayuutann", [Accept: "application/activity+json"], _) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/mayumayu.json")
	}}
	end

	def get(
	"http://mastodon.example.org/@admin/99541947525187367",
	[Accept: "application/activity+json"],
	_
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/mastodon-note-object.json")
	}}
	end

	def get(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394",
	[Accept: "application/activity+json"],
	_
	) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/mayumayupost.json")
	}}
	end

	def get("https://shitposter.club/notice/7369654", _, _) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/7369654.html")
	}}
	end

	def get("https://shitposter.club/api/statuses/show/7369654.atom", _body, _headers) do
	{:ok,
	%Response{
	status_code: 200,
	body: File.read!("test/fixtures/httpoison_mock/7369654.atom")
	}}
	end

	def get(url, body, headers) do
	{:error,
	"Not implemented the mock response for get #{inspect(url)}, #{inspect(body)}, #{
	inspect(headers)
	}"}
	end

	- def post(url, body, headers) do
	+ def post(url, _body, _headers) do
	{:error, "Not implemented the mock response for post #{inspect(url)}"}
	end

	- def post(url, body, headers, options) do
	+ def post(url, _body, _headers, _options) do
	{:error, "Not implemented the mock response for post #{inspect(url)}"}
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 11:41 AM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1769443
Default Alt Text: (63 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions