No OneTemporary
Actions

Authored By

Unknown

Size

145 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/config/config.exs b/config/config.exs
	index 6b1e31398..eaf20e8f9 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,122 +1,123 @@
	# This file is responsible for configuring your application
	# and its dependencies with the aid of the Mix.Config module.
	#
	# This configuration file is loaded before any dependency and
	# is restricted to this project.
	use Mix.Config

	# General application configuration
	config :pleroma, ecto_repos: [Pleroma.Repo]

	config :pleroma, Pleroma.Repo, types: Pleroma.PostgresTypes

	config :pleroma, Pleroma.Upload,
	uploads: "uploads",
	strip_exif: false

	config :pleroma, :emoji, shortcode_globs: ["/emoji/custom/*/.png"]

	config :pleroma, :uri_schemes, additionnal_schemes: []

	# Configures the endpoint
	config :pleroma, Pleroma.Web.Endpoint,
	url: [host: "localhost"],
	protocol: "https",
	secret_key_base: "aK4Abxf29xU9TTDKre9coZPUgevcVCFQJe/5xP/7Lt4BEif6idBIbjupVbOrbKxl",
	render_errors: [view: Pleroma.Web.ErrorView, accepts: ~w(json)],
	pubsub: [name: Pleroma.PubSub, adapter: Phoenix.PubSub.PG2]

	# Configures Elixir's Logger
	config :logger, :console,
	format: "$time $metadata[$level] $message\n",
	metadata: [:request_id]

	config :mime, :types, %{
	"application/xml" => ["xml"],
	"application/xrd+xml" => ["xrd+xml"],
	"application/activity+json" => ["activity+json"],
	"application/ld+json" => ["activity+json"]
	}

	config :pleroma, :websub, Pleroma.Web.Websub
	config :pleroma, :ostatus, Pleroma.Web.OStatus
	config :pleroma, :httpoison, Pleroma.HTTP

	version =
	with {version, 0} <- System.cmd("git", ["rev-parse", "HEAD"]) do
	"Pleroma #{Mix.Project.config()[:version]} #{String.trim(version)}"
	else
	_ -> "Pleroma #{Mix.Project.config()[:version]} dev"
	end

	# Configures http settings, upstream proxy etc.
	config :pleroma, :http, proxy_url: nil

	config :pleroma, :instance,
	version: version,
	name: "Pleroma",
	email: "example@example.com",
	description: "A Pleroma instance, an alternative fediverse server",
	limit: 5000,
	upload_limit: 16_000_000,
	registrations_open: true,
	federating: true,
	+ allow_relay: true,
	rewrite_policy: Pleroma.Web.ActivityPub.MRF.NoOpPolicy,
	public: true,
	quarantined_instances: []

	config :pleroma, :fe,
	theme: "pleroma-dark",
	logo: "/static/logo.png",
	background: "/static/aurora_borealis.jpg",
	redirect_root_no_login: "/main/all",
	redirect_root_login: "/main/friends",
	show_instance_panel: true,
	scope_options_enabled: false,
	collapse_message_with_subject: false

	config :pleroma, :activitypub,
	accept_blocks: true,
	unfollow_blocked: true,
	outgoing_blocks: true

	config :pleroma, :user, deny_follow_blocked: true

	config :pleroma, :mrf_rejectnonpublic,
	allow_followersonly: false,
	allow_direct: false

	config :pleroma, :mrf_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	reject: [],
	accept: []

	config :pleroma, :media_proxy,
	enabled: false,
	redirect_on_failure: true

	# base_url: "https://cache.pleroma.social"

	config :pleroma, :chat, enabled: true

	config :ecto, json_library: Jason

	config :phoenix, :format_encoders, json: Jason

	config :pleroma, :gopher,
	enabled: false,
	ip: {0, 0, 0, 0},
	port: 9999

	config :pleroma, :suggestions,
	enabled: false,
	third_party_engine:
	"http://vinayaka.distsn.org/cgi-bin/vinayaka-user-match-suggestions-api.cgi?{{host}}+{{user}}",
	timeout: 300_000,
	web: "https://vinayaka.distsn.org/?{{host}}+{{user}}"

	# Import environment specific config. This must remain at the bottom
	# of this file so it overrides the configuration defined above.
	import_config "#{Mix.env()}.exs"
	diff --git a/lib/mix/tasks/relay_follow.ex b/lib/mix/tasks/relay_follow.ex
	new file mode 100644
	index 000000000..ac6f20924
	--- /dev/null
	+++ b/lib/mix/tasks/relay_follow.ex
	@@ -0,0 +1,15 @@
	+defmodule Mix.Tasks.RelayFollow do
	+ use Mix.Task
	+ require Logger
	+ alias Pleroma.Web.ActivityPub.Relay
	+
	+ @shortdoc "Follows a remote relay"
	+ def run([target]) do
	+ Mix.Task.run("app.start")
	+
	+ :ok = Relay.follow(target)
	+
	+ # put this task to sleep to allow the genserver to push out the messages
	+ :timer.sleep(500)
	+ end
	+end
	diff --git a/lib/mix/tasks/relay_unfollow.ex b/lib/mix/tasks/relay_unfollow.ex
	new file mode 100644
	index 000000000..4621ace83
	--- /dev/null
	+++ b/lib/mix/tasks/relay_unfollow.ex
	@@ -0,0 +1,15 @@
	+defmodule Mix.Tasks.RelayUnfollow do
	+ use Mix.Task
	+ require Logger
	+ alias Pleroma.Web.ActivityPub.Relay
	+
	+ @shortdoc "Follows a remote relay"
	+ def run([target]) do
	+ Mix.Task.run("app.start")
	+
	+ :ok = Relay.unfollow(target)
	+
	+ # put this task to sleep to allow the genserver to push out the messages
	+ :timer.sleep(500)
	+ end
	+end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 7d7f3b23e..88293a4f3 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,705 +1,729 @@
	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.{Changeset, Query}
	alias Pleroma.{Repo, User, Object, Web, Activity, Notification}
	alias Comeonin.Pbkdf2
	alias Pleroma.Web.{OStatus, Websub}
	alias Pleroma.Web.ActivityPub.{Utils, ActivityPub}

	schema "users" do
	field(:bio, :string)
	field(:email, :string)
	field(:name, :string)
	field(:nickname, :string)
	field(:password_hash, :string)
	field(:password, :string, virtual: true)
	field(:password_confirmation, :string, virtual: true)
	field(:following, {:array, :string}, default: [])
	field(:ap_id, :string)
	field(:avatar, :map)
	field(:local, :boolean, default: true)
	field(:info, :map, default: %{})
	field(:follower_address, :string)
	field(:search_distance, :float, virtual: true)
	has_many(:notifications, Notification)

	timestamps()
	end

	def avatar_url(user) do
	case user.avatar do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> "#{Web.base_url()}/images/avi.png"
	end
	end

	def banner_url(user) do
	case user.info["banner"] do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> "#{Web.base_url()}/images/banner.png"
	end
	end

	def ap_id(%User{nickname: nickname}) do
	"#{Web.base_url()}/users/#{nickname}"
	end

	def ap_followers(%User{} = user) do
	"#{ap_id(user)}/followers"
	end

	def follow_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:following])
	\|> validate_required([:following])
	end

	def info_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:info])
	\|> validate_required([:info])
	end

	def user_info(%User{} = user) do
	oneself = if user.local, do: 1, else: 0

	%{
	following_count: length(user.following) - oneself,
	note_count: user.info["note_count"] \|\| 0,
	follower_count: user.info["follower_count"] \|\| 0,
	locked: user.info["locked"] \|\| false
	}
	end

	@email_regex ~r/^[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/
	def remote_user_creation(params) do
	changes =
	%User{}
	\|> cast(params, [:bio, :name, :ap_id, :nickname, :info, :avatar])
	- \|> validate_required([:name, :ap_id, :nickname])
	+ \|> validate_required([:name, :ap_id])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, max: 100)
	\|> put_change(:local, false)

	if changes.valid? do
	case changes.changes[:info]["source_data"] do
	%{"followers" => followers} ->
	changes
	\|> put_change(:follower_address, followers)

	_ ->
	followers = User.ap_followers(%User{nickname: changes.changes[:nickname]})

	changes
	\|> put_change(:follower_address, followers)
	end
	else
	changes
	end
	end

	def update_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:bio, :name])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, ~r/^[a-zA-Z\d]+$/)
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, min: 1, max: 100)
	end

	def upgrade_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:bio, :name, :info, :follower_address, :avatar])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, ~r/^[a-zA-Z\d]+$/)
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, max: 100)
	end

	def password_update_changeset(struct, params) do
	changeset =
	struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)

	if changeset.valid? do
	hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])

	changeset
	\|> put_change(:password_hash, hashed)
	else
	changeset
	end
	end

	def reset_password(user, data) do
	update_and_set_cache(password_update_changeset(user, data))
	end

	def register_changeset(struct, params \\ %{}) do
	changeset =
	struct
	\|> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
	\|> validate_required([:email, :name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, ~r/^[a-zA-Z\d]+$/)
	\|> validate_format(:email, @email_regex)
	\|> validate_length(:bio, max: 1000)
	\|> validate_length(:name, min: 1, max: 100)

	if changeset.valid? do
	hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])
	ap_id = User.ap_id(%User{nickname: changeset.changes[:nickname]})
	followers = User.ap_followers(%User{nickname: changeset.changes[:nickname]})

	changeset
	\|> put_change(:password_hash, hashed)
	\|> put_change(:ap_id, ap_id)
	\|> put_change(:following, [followers])
	\|> put_change(:follower_address, followers)
	else
	changeset
	end
	end

	def maybe_direct_follow(%User{} = follower, %User{info: info} = followed) do
	user_config = Application.get_env(:pleroma, :user)
	deny_follow_blocked = Keyword.get(user_config, :deny_follow_blocked)

	user_info = user_info(followed)

	should_direct_follow =
	cond do
	# if the account is locked, don't pre-create the relationship
	user_info[:locked] == true ->
	false

	# if the users are blocking each other, we shouldn't even be here, but check for it anyway
	deny_follow_blocked and
	(User.blocks?(follower, followed) or User.blocks?(followed, follower)) ->
	false

	# if OStatus, then there is no three-way handshake to follow
	User.ap_enabled?(followed) != true ->
	true

	# if there are no other reasons not to, just pre-create the relationship
	true ->
	true
	end

	if should_direct_follow do
	follow(follower, followed)
	else
	{:ok, follower}
	end
	end

	def maybe_follow(%User{} = follower, %User{info: info} = followed) do
	if not following?(follower, followed) do
	follow(follower, followed)
	else
	{:ok, follower}
	end
	end

	def follow(%User{} = follower, %User{info: info} = followed) do
	user_config = Application.get_env(:pleroma, :user)
	deny_follow_blocked = Keyword.get(user_config, :deny_follow_blocked)

	ap_followers = followed.follower_address

	cond do
	following?(follower, followed) or info["deactivated"] ->
	{:error, "Could not follow user: #{followed.nickname} is already on your list."}

	deny_follow_blocked and blocks?(followed, follower) ->
	{:error, "Could not follow user: #{followed.nickname} blocked you."}

	true ->
	if !followed.local && follower.local && !ap_enabled?(followed) do
	Websub.subscribe(follower, followed)
	end

	following =
	[ap_followers \| follower.following]
	\|> Enum.uniq()

	follower =
	follower
	\|> follow_changeset(%{following: following})
	\|> update_and_set_cache

	{:ok, _} = update_follower_count(followed)

	follower
	end
	end

	def unfollow(%User{} = follower, %User{} = followed) do
	ap_followers = followed.follower_address

	if following?(follower, followed) and follower.ap_id != followed.ap_id do
	following =
	follower.following
	\|> List.delete(ap_followers)

	{:ok, follower} =
	follower
	\|> follow_changeset(%{following: following})
	\|> update_and_set_cache

	{:ok, followed} = update_follower_count(followed)

	{:ok, follower, Utils.fetch_latest_follow(follower, followed)}
	else
	{:error, "Not subscribed!"}
	end
	end

	def following?(%User{} = follower, %User{} = followed) do
	Enum.member?(follower.following, followed.follower_address)
	end

	def locked?(%User{} = user) do
	user.info["locked"] \|\| false
	end

	def get_by_ap_id(ap_id) do
	Repo.get_by(User, ap_id: ap_id)
	end

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset) do
	Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
	Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user))
	{:ok, user}
	else
	e -> e
	end
	end

	def invalidate_cache(user) do
	Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	Cachex.del(:user_cache, "nickname:#{user.nickname}")
	end

	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"
	Cachex.fetch!(:user_cache, key, fn _ -> get_by_ap_id(ap_id) end)
	end

	def get_cached_by_nickname(nickname) do
	key = "nickname:#{nickname}"
	Cachex.fetch!(:user_cache, key, fn _ -> get_or_fetch_by_nickname(nickname) end)
	end

	def get_by_nickname(nickname) do
	Repo.get_by(User, nickname: nickname)
	end

	def get_by_nickname_or_email(nickname_or_email) do
	case user = Repo.get_by(User, nickname: nickname_or_email) do
	%User{} -> user
	nil -> Repo.get_by(User, email: nickname_or_email)
	end
	end

	def get_cached_user_info(user) do
	key = "user_info:#{user.id}"
	Cachex.fetch!(:user_cache, key, fn _ -> user_info(user) end)
	end

	def fetch_by_nickname(nickname) do
	ap_try = ActivityPub.make_user_from_nickname(nickname)

	case ap_try do
	{:ok, user} -> {:ok, user}
	_ -> OStatus.make_user(nickname)
	end
	end

	def get_or_fetch_by_nickname(nickname) do
	with %User{} = user <- get_by_nickname(nickname) do
	user
	else
	_e ->
	with [_nick, _domain] <- String.split(nickname, "@"),
	{:ok, user} <- fetch_by_nickname(nickname) do
	user
	else
	_e -> nil
	end
	end
	end

	def get_followers_query(%User{id: id, follower_address: follower_address}) do
	from(
	u in User,
	where: fragment("? <@ ?", ^[follower_address], u.following),
	where: u.id != ^id
	)
	end

	def get_followers(user) do
	q = get_followers_query(user)

	{:ok, Repo.all(q)}
	end

	def get_friends_query(%User{id: id, following: following}) do
	from(
	u in User,
	where: u.follower_address in ^following,
	where: u.id != ^id
	)
	end

	def get_friends(user) do
	q = get_friends_query(user)

	{:ok, Repo.all(q)}
	end

	def get_follow_requests_query(%User{} = user) do
	from(
	a in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Follow'",
	a.data
	),
	where:
	fragment(
	"? ->> 'state' = 'pending'",
	a.data
	),
	where:
	fragment(
	"? @> ?",
	a.data,
	^%{"object" => user.ap_id}
	)
	)
	end

	def get_follow_requests(%User{} = user) do
	q = get_follow_requests_query(user)
	reqs = Repo.all(q)

	users =
	Enum.map(reqs, fn req -> req.actor end)
	\|> Enum.uniq()
	\|> Enum.map(fn ap_id -> get_by_ap_id(ap_id) end)
	\|> Enum.filter(fn u -> !following?(u, user) end)

	{:ok, users}
	end

	def increase_note_count(%User{} = user) do
	note_count = (user.info["note_count"] \|\| 0) + 1
	new_info = Map.put(user.info, "note_count", note_count)

	cs = info_changeset(user, %{info: new_info})

	update_and_set_cache(cs)
	end

	def decrease_note_count(%User{} = user) do
	note_count = user.info["note_count"] \|\| 0
	note_count = if note_count <= 0, do: 0, else: note_count - 1
	new_info = Map.put(user.info, "note_count", note_count)

	cs = info_changeset(user, %{info: new_info})

	update_and_set_cache(cs)
	end

	def update_note_count(%User{} = user) do
	note_count_query =
	from(
	a in Object,
	where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
	select: count(a.id)
	)

	note_count = Repo.one(note_count_query)

	new_info = Map.put(user.info, "note_count", note_count)

	cs = info_changeset(user, %{info: new_info})

	update_and_set_cache(cs)
	end

	def update_follower_count(%User{} = user) do
	follower_count_query =
	from(
	u in User,
	where: ^user.follower_address in u.following,
	where: u.id != ^user.id,
	select: count(u.id)
	)

	follower_count = Repo.one(follower_count_query)

	new_info = Map.put(user.info, "follower_count", follower_count)

	cs = info_changeset(user, %{info: new_info})

	update_and_set_cache(cs)
	end

	def get_notified_from_activity_query(to) do
	from(
	u in User,
	where: u.ap_id in ^to,
	where: u.local == true
	)
	end

	def get_notified_from_activity(%Activity{recipients: to, data: %{"type" => "Announce"} = data}) do
	object = Object.normalize(data["object"])

	# ensure that the actor who published the announced object appears only once
	to =
	(to ++ [object.data["actor"]])
	\|> Enum.uniq()

	query = get_notified_from_activity_query(to)

	Repo.all(query)
	end

	def get_notified_from_activity(%Activity{recipients: to}) do
	query = get_notified_from_activity_query(to)

	Repo.all(query)
	end

	def get_recipients_from_activity(%Activity{recipients: to}) do
	query =
	from(
	u in User,
	where: u.ap_id in ^to,
	or_where: fragment("? && ?", u.following, ^to)
	)

	query = from(u in query, where: u.local == true)

	Repo.all(query)
	end

	def search(query, resolve) do
	# strip the beginning @ off if there is a query
	query = String.trim_leading(query, "@")

	if resolve do
	User.get_or_fetch_by_nickname(query)
	end

	inner =
	from(
	u in User,
	select_merge: %{
	search_distance:
	fragment(
	"? <-> (? \|\| ?)",
	^query,
	u.nickname,
	u.name
	)
	- }
	+ },
	+ where: not is_nil(u.nickname)
	)

	q =
	from(
	s in subquery(inner),
	order_by: s.search_distance,
	limit: 20
	)

	Repo.all(q)
	end

	def block(blocker, %User{ap_id: ap_id} = blocked) do
	# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
	blocker =
	if following?(blocker, blocked) do
	{:ok, blocker, _} = unfollow(blocker, blocked)
	blocker
	else
	blocker
	end

	if following?(blocked, blocker) do
	unfollow(blocked, blocker)
	end

	blocks = blocker.info["blocks"] \|\| []
	new_blocks = Enum.uniq([ap_id \| blocks])
	new_info = Map.put(blocker.info, "blocks", new_blocks)

	cs = User.info_changeset(blocker, %{info: new_info})
	update_and_set_cache(cs)
	end

	# helper to handle the block given only an actor's AP id
	def block(blocker, %{ap_id: ap_id}) do
	block(blocker, User.get_by_ap_id(ap_id))
	end

	def unblock(user, %{ap_id: ap_id}) do
	blocks = user.info["blocks"] \|\| []
	new_blocks = List.delete(blocks, ap_id)
	new_info = Map.put(user.info, "blocks", new_blocks)

	cs = User.info_changeset(user, %{info: new_info})
	update_and_set_cache(cs)
	end

	def blocks?(user, %{ap_id: ap_id}) do
	blocks = user.info["blocks"] \|\| []
	domain_blocks = user.info["domain_blocks"] \|\| []
	%{host: host} = URI.parse(ap_id)

	Enum.member?(blocks, ap_id) \|\|
	Enum.any?(domain_blocks, fn domain ->
	host == domain
	end)
	end

	def block_domain(user, domain) do
	domain_blocks = user.info["domain_blocks"] \|\| []
	new_blocks = Enum.uniq([domain \| domain_blocks])
	new_info = Map.put(user.info, "domain_blocks", new_blocks)

	cs = User.info_changeset(user, %{info: new_info})
	update_and_set_cache(cs)
	end

	def unblock_domain(user, domain) do
	blocks = user.info["domain_blocks"] \|\| []
	new_blocks = List.delete(blocks, domain)
	new_info = Map.put(user.info, "domain_blocks", new_blocks)

	cs = User.info_changeset(user, %{info: new_info})
	update_and_set_cache(cs)
	end

	def local_user_query() do
	- from(u in User, where: u.local == true)
	+ from(
	+ u in User,
	+ where: u.local == true,
	+ where: not is_nil(u.nickname)
	+ )
	end

	def deactivate(%User{} = user) do
	new_info = Map.put(user.info, "deactivated", true)
	cs = User.info_changeset(user, %{info: new_info})
	update_and_set_cache(cs)
	end

	def delete(%User{} = user) do
	{:ok, user} = User.deactivate(user)

	# Remove all relationships
	{:ok, followers} = User.get_followers(user)

	followers
	\|> Enum.each(fn follower -> User.unfollow(follower, user) end)

	{:ok, friends} = User.get_friends(user)

	friends
	\|> Enum.each(fn followed -> User.unfollow(user, followed) end)

	query = from(a in Activity, where: a.actor == ^user.ap_id)

	Repo.all(query)
	\|> Enum.each(fn activity ->
	case activity.data["type"] do
	"Create" ->
	ActivityPub.delete(Object.normalize(activity.data["object"]))

	# TODO: Do something with likes, follows, repeats.
	_ ->
	"Doing nothing"
	end
	end)

	:ok
	end

	def get_or_fetch_by_ap_id(ap_id) do
	if user = get_by_ap_id(ap_id) do
	user
	else
	ap_try = ActivityPub.make_user_from_ap_id(ap_id)

	case ap_try do
	{:ok, user} ->
	user

	_ ->
	case OStatus.make_user(ap_id) do
	{:ok, user} -> user
	_ -> {:error, "Could not fetch by AP id"}
	end
	end
	end
	end

	+ def get_or_create_instance_user do
	+ relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"
	+
	+ if user = get_by_ap_id(relay_uri) do
	+ user
	+ else
	+ changes =
	+ %User{}
	+ \|> cast(%{}, [:ap_id, :nickname, :local])
	+ \|> put_change(:ap_id, relay_uri)
	+ \|> put_change(:nickname, nil)
	+ \|> put_change(:local, true)
	+ \|> put_change(:follower_address, relay_uri <> "/followers")
	+
	+ {:ok, user} = Repo.insert(changes)
	+ user
	+ end
	+ end
	+
	# AP style
	def public_key_from_info(%{
	"source_data" => %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
	}) do
	key =
	:public_key.pem_decode(public_key_pem)
	\|> hd()
	\|> :public_key.pem_entry_decode()

	{:ok, key}
	end

	# OStatus Magic Key
	def public_key_from_info(%{"magic_key" => magic_key}) do
	{:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
	end

	def get_public_key_for_ap_id(ap_id) do
	with %User{} = user <- get_or_fetch_by_ap_id(ap_id),
	{:ok, public_key} <- public_key_from_info(user.info) do
	{:ok, public_key}
	else
	_ -> :error
	end
	end

	defp blank?(""), do: nil
	defp blank?(n), do: n

	def insert_or_update_user(data) do
	data =
	data
	\|> Map.put(:name, blank?(data[:name]) \|\| data[:nickname])

	cs = User.remote_user_creation(data)
	Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
	end

	def ap_enabled?(%User{info: info}), do: info["ap_enabled"]
	def ap_enabled?(_), do: false

	def get_or_fetch(uri_or_nickname) do
	if String.starts_with?(uri_or_nickname, "http") do
	get_or_fetch_by_ap_id(uri_or_nickname)
	else
	get_or_fetch_by_nickname(uri_or_nickname)
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 298d7817a..68b398786 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,740 +1,751 @@
	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)

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

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

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

	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.normalize(map),
	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
	public = "https://www.w3.org/ns/activitystreams#Public"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	def announce(
	%User{ap_id: _} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true
	) 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, object}
	else
	_e -> {:ok, object}
	end
	end

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

	def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
	with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
	unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
	{:ok, activity} <- insert(unfollow_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

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

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

	with 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
	ap_config = Application.get_env(:pleroma, :activitypub)
	unfollow_blocked = Keyword.get(ap_config, :unfollow_blocked)
	outgoing_blocks = Keyword.get(ap_config, :outgoing_blocks)

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

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

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

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

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

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

	query = from(activity in Activity)

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

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

	Repo.all(query)
	end

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

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

	@valid_visibilities ~w[direct unlisted public private]

	defp restrict_visibility(query, %{visibility: "direct"}) do
	public = "https://www.w3.org/ns/activitystreams#Public"

	from(
	activity in query,
	join: sender in User,
	on: sender.ap_id == activity.actor,
	# Are non-direct statuses with no to/cc possible?
	where:
	fragment(
	"not (? && ?)",
	[^public, sender.follower_address],
	activity.recipients
	)
	)
	end

	defp restrict_visibility(_query, %{visibility: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not restrict visibility to #{visibility}")
	end

	defp restrict_visibility(query, _visibility), do: query

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

	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

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

	defp restrict_replies(query, _), do: query

	# 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"] \|\| []
	domain_blocks = info["domain_blocks"] \|\| []

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

	defp restrict_blocked(query, _), do: query

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

	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)
	\|> restrict_visibility(opts)
	\|> restrict_replies(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, Application.get_env(:pleroma, :instance)[:dedupe_media])
	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"]}]
	}

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

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

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

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

	@quarantined_instances Keyword.get(@instance, :quarantined_instances, [])

	def should_federate?(inbox, public) do
	if public do
	true
	else
	inbox_info = URI.parse(inbox)
	inbox_info.host not in @quarantined_instances
	end
	end

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

	public = is_public?(activity)

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

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

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

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

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

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

	@httpoison.post(
	inbox,
	json,
	[
	{"Content-Type", "application/activity+json"},
	{"signature", signature},
	{"digest", digest}
	],
	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.normalize(data),
	params <- %{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => data["attributedTo"],
	"object" => data
	},
	{:ok, activity} <- Transmogrifier.handle_incoming(params) do
	{:ok, Object.normalize(activity.data["object"])}
	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.normalize(activity.data["object"])}
	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/activity_pub_controller.ex b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	index d337532d0..52b2a467e 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	@@ -1,121 +1,133 @@
	defmodule Pleroma.Web.ActivityPub.ActivityPubController do
	use Pleroma.Web, :controller
	alias Pleroma.{User, Object}
	alias Pleroma.Web.ActivityPub.{ObjectView, UserView}
	alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.Federator

	require Logger

	action_fallback(:errors)

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

	def object(conn, %{"uuid" => uuid}) do
	with ap_id <- o_status_url(conn, :object, uuid),
	%Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	{_, true} <- {:public?, ActivityPub.is_public?(object)} do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(ObjectView.render("object.json", %{object: object}))
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def following(conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("following.json", %{user: user, page: page}))
	end
	end

	def following(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("following.json", %{user: user}))
	end
	end

	def followers(conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("followers.json", %{user: user, page: page}))
	end
	end

	def followers(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("followers.json", %{user: user}))
	end
	end

	def outbox(conn, %{"nickname" => nickname, "max_id" => max_id}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("outbox.json", %{user: user, max_id: max_id}))
	end
	end

	def outbox(conn, %{"nickname" => nickname}) do
	outbox(conn, %{"nickname" => nickname, "max_id" => nil})
	end

	# TODO: Ensure that this inbox is a recipient of the message
	def inbox(%{assigns: %{valid_signature: true}} = conn, params) do
	Federator.enqueue(:incoming_ap_doc, params)
	json(conn, "ok")
	end

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

	if !String.contains?(headers["signature"] \|\| "", params["actor"]) do
	Logger.info("Signature not from author, relayed message, fetching from source")
	ActivityPub.fetch_object_from_id(params["object"]["id"])
	else
	Logger.info("Signature error - make sure you are forwarding the HTTP Host header!")
	Logger.info("Could not validate #{params["actor"]}")
	Logger.info(inspect(conn.req_headers))
	end

	json(conn, "ok")
	end

	+ def relay(conn, params) do
	+ with %User{} = user <- Relay.get_actor(),
	+ {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	+ conn
	+ \|> put_resp_header("content-type", "application/activity+json")
	+ \|> json(UserView.render("user.json", %{user: user}))
	+ else
	+ nil -> {:error, :not_found}
	+ end
	+ end
	+
	def errors(conn, {:error, :not_found}) do
	conn
	\|> put_status(404)
	\|> json("Not found")
	end

	def errors(conn, _e) do
	conn
	\|> put_status(500)
	\|> json("error")
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/relay.ex b/lib/pleroma/web/activity_pub/relay.ex
	new file mode 100644
	index 000000000..d30853d62
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/relay.ex
	@@ -0,0 +1,44 @@
	+defmodule Pleroma.Web.ActivityPub.Relay do
	+ alias Pleroma.{User, Object, Activity}
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	+ require Logger
	+
	+ def get_actor do
	+ User.get_or_create_instance_user()
	+ end
	+
	+ def follow(target_instance) do
	+ with %User{} = local_user <- get_actor(),
	+ %User{} = target_user <- User.get_or_fetch_by_ap_id(target_instance),
	+ {:ok, activity} <- ActivityPub.follow(local_user, target_user) do
	+ Logger.info("relay: followed instance: #{target_instance}; id=#{activity.data["id"]}")
	+ else
	+ e -> Logger.error("error: #{inspect(e)}")
	+ end
	+
	+ :ok
	+ end
	+
	+ def unfollow(target_instance) do
	+ with %User{} = local_user <- get_actor(),
	+ %User{} = target_user <- User.get_or_fetch_by_ap_id(target_instance),
	+ {:ok, activity} <- ActivityPub.unfollow(local_user, target_user) do
	+ Logger.info("relay: unfollowed instance: #{target_instance}: id=#{activity.data["id"]}")
	+ else
	+ e -> Logger.error("error: #{inspect(e)}")
	+ end
	+
	+ :ok
	+ end
	+
	+ def publish(%Activity{data: %{"type" => "Create"}} = activity) do
	+ with %User{} = user <- get_actor(),
	+ %Object{} = object <- Object.normalize(activity.data["object"]["id"]) do
	+ ActivityPub.announce(user, object)
	+ else
	+ e -> Logger.error("error: #{inspect(e)}")
	+ end
	+ end
	+
	+ def publish(_), do: nil
	+end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index 7cdc1656b..0664b5a2e 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,455 +1,480 @@
	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
	require Logger

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

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

	def 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 ["Article", "Note", "Video"] 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
	likes = if is_list(object.data["likes"]), do: object.data["likes"], else: []

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

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

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

	#### Follow-related helpers

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

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

	data = if activity_id, do: Map.put(data, "id", activity_id), else: data
	data = if User.locked?(followed), do: Map.put(data, "state", "pending"), else: data

	data
	end

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

	Repo.one(query)
	end

	#### Announce-related helpers

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

	Repo.one(query)
	end

	@doc """
	Make announce activity data for the given actor and object
	"""
	+ # for relayed messages, we only want to send to subscribers
	+ def make_announce_data(
	+ %User{ap_id: ap_id, nickname: nil} = user,
	+ %Object{data: %{"id" => id}} = object,
	+ activity_id
	+ ) do
	+ data = %{
	+ "type" => "Announce",
	+ "actor" => ap_id,
	+ "object" => id,
	+ "to" => [user.follower_address],
	+ "cc" => [],
	+ "context" => object.data["context"]
	+ }
	+
	+ if activity_id, do: Map.put(data, "id", activity_id), else: data
	+ end
	+
	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id
	) 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
	+ def add_announce_to_object(
	+ %Activity{
	+ data: %{"actor" => actor, "cc" => ["https://www.w3.org/ns/activitystreams#Public"]}
	+ },
	+ object
	+ ) do
	announcements =
	if is_list(object.data["announcements"]), do: object.data["announcements"], else: []

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

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

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

	#### Unfollow-related helpers

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

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

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

	Repo.one(query)
	end

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

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

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

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

	#### Create-related helpers

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

	%{
	"type" => "Create",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/views/user_view.ex b/lib/pleroma/web/activity_pub/views/user_view.ex
	index fc76f2940..16419e1b7 100644
	--- a/lib/pleroma/web/activity_pub/views/user_view.ex
	+++ b/lib/pleroma/web/activity_pub/views/user_view.ex
	@@ -1,164 +1,193 @@
	defmodule Pleroma.Web.ActivityPub.UserView do
	use Pleroma.Web, :view
	alias Pleroma.Web.Salmon
	alias Pleroma.Web.WebFinger
	alias Pleroma.User
	alias Pleroma.Repo
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	import Ecto.Query

	+ # the instance itself is not a Person, but instead an Application
	+ def render("user.json", %{user: %{nickname: nil} = user}) do
	+ {:ok, user} = WebFinger.ensure_keys_present(user)
	+ {:ok, _, public_key} = Salmon.keys_from_pem(user.info["keys"])
	+ public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
	+ public_key = :public_key.pem_encode([public_key])
	+
	+ %{
	+ "@context" => "https://www.w3.org/ns/activitystreams",
	+ "id" => user.ap_id,
	+ "type" => "Application",
	+ "following" => "#{user.ap_id}/following",
	+ "followers" => "#{user.ap_id}/followers",
	+ "inbox" => "#{user.ap_id}/inbox",
	+ "name" => "Pleroma",
	+ "summary" => "Virtual actor for Pleroma relay",
	+ "url" => user.ap_id,
	+ "manuallyApprovesFollowers" => false,
	+ "publicKey" => %{
	+ "id" => "#{user.ap_id}#main-key",
	+ "owner" => user.ap_id,
	+ "publicKeyPem" => public_key
	+ },
	+ "endpoints" => %{
	+ "sharedInbox" => "#{Pleroma.Web.Endpoint.url()}/inbox"
	+ }
	+ }
	+ end
	+
	def render("user.json", %{user: user}) do
	{:ok, user} = WebFinger.ensure_keys_present(user)
	{:ok, _, public_key} = Salmon.keys_from_pem(user.info["keys"])
	public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
	public_key = :public_key.pem_encode([public_key])

	%{
	"id" => user.ap_id,
	"type" => "Person",
	"following" => "#{user.ap_id}/following",
	"followers" => "#{user.ap_id}/followers",
	"inbox" => "#{user.ap_id}/inbox",
	"outbox" => "#{user.ap_id}/outbox",
	"preferredUsername" => user.nickname,
	"name" => user.name,
	"summary" => user.bio,
	"url" => user.ap_id,
	"manuallyApprovesFollowers" => user.info["locked"] \|\| false,
	"publicKey" => %{
	"id" => "#{user.ap_id}#main-key",
	"owner" => user.ap_id,
	"publicKeyPem" => public_key
	},
	"endpoints" => %{
	"sharedInbox" => "#{Pleroma.Web.Endpoint.url()}/inbox"
	},
	"icon" => %{
	"type" => "Image",
	"url" => User.avatar_url(user)
	},
	"image" => %{
	"type" => "Image",
	"url" => User.banner_url(user)
	},
	"tag" => user.info["source_data"]["tag"] \|\| []
	}
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("following.json", %{user: user, page: page}) do
	query = User.get_friends_query(user)
	query = from(user in query, select: [:ap_id])
	following = Repo.all(query)

	collection(following, "#{user.ap_id}/following", page)
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("following.json", %{user: user}) do
	query = User.get_friends_query(user)
	query = from(user in query, select: [:ap_id])
	following = Repo.all(query)

	%{
	"id" => "#{user.ap_id}/following",
	"type" => "OrderedCollection",
	"totalItems" => length(following),
	"first" => collection(following, "#{user.ap_id}/following", 1)
	}
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("followers.json", %{user: user, page: page}) do
	query = User.get_followers_query(user)
	query = from(user in query, select: [:ap_id])
	followers = Repo.all(query)

	collection(followers, "#{user.ap_id}/followers", page)
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("followers.json", %{user: user}) do
	query = User.get_followers_query(user)
	query = from(user in query, select: [:ap_id])
	followers = Repo.all(query)

	%{
	"id" => "#{user.ap_id}/followers",
	"type" => "OrderedCollection",
	"totalItems" => length(followers),
	"first" => collection(followers, "#{user.ap_id}/followers", 1)
	}
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("outbox.json", %{user: user, max_id: max_qid}) do
	# XXX: technically note_count is wrong for this, but it's better than nothing
	info = User.user_info(user)

	params = %{
	"limit" => "10"
	}

	params =
	if max_qid != nil do
	Map.put(params, "max_id", max_qid)
	else
	params
	end

	activities = ActivityPub.fetch_user_activities(user, nil, params)
	min_id = Enum.at(Enum.reverse(activities), 0).id
	max_id = Enum.at(activities, 0).id

	collection =
	Enum.map(activities, fn act ->
	{:ok, data} = Transmogrifier.prepare_outgoing(act.data)
	data
	end)

	iri = "#{user.ap_id}/outbox"

	page = %{
	"id" => "#{iri}?max_id=#{max_id}",
	"type" => "OrderedCollectionPage",
	"partOf" => iri,
	"totalItems" => info.note_count,
	"orderedItems" => collection,
	"next" => "#{iri}?max_id=#{min_id - 1}"
	}

	if max_qid == nil do
	%{
	"id" => iri,
	"type" => "OrderedCollection",
	"totalItems" => info.note_count,
	"first" => page
	}
	\|> Map.merge(Utils.make_json_ld_header())
	else
	page \|> Map.merge(Utils.make_json_ld_header())
	end
	end

	def collection(collection, iri, page, total \\ nil) do
	offset = (page - 1) * 10
	items = Enum.slice(collection, offset, 10)
	items = Enum.map(items, fn user -> user.ap_id end)
	total = total \|\| length(collection)

	map = %{
	"id" => "#{iri}?page=#{page}",
	"type" => "OrderedCollectionPage",
	"partOf" => iri,
	"totalItems" => total,
	"orderedItems" => items
	}

	if offset < total do
	Map.put(map, "next", "#{iri}?page=#{page + 1}")
	end
	end
	end
	diff --git a/lib/pleroma/web/federator/federator.ex b/lib/pleroma/web/federator/federator.ex
	index ccefb0bdf..078f3ec11 100644
	--- a/lib/pleroma/web/federator/federator.ex
	+++ b/lib/pleroma/web/federator/federator.ex
	@@ -1,212 +1,218 @@
	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.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	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 init(args) do
	{:ok, args}
	end

	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)
	+
	+ if Mix.env() != :test do
	+ Logger.info(fn -> "Relaying #{activity.data["id"]} out" end)
	+ Pleroma.Web.ActivityPub.Relay.publish(activity)
	+ end
	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")

	params = Utils.normalize_params(params)

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

	_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)
	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
	%{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/router.ex b/lib/pleroma/web/router.ex
	index 68e159f6a..927323794 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,389 +1,401 @@
	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router

	alias Pleroma.{Repo, User, Web.Router}

	@instance Application.get_env(:pleroma, :instance)
	@federating Keyword.get(@instance, :federating)
	+ @allow_relay Keyword.get(@instance, :allow_relay)
	@public Keyword.get(@instance, :public)
	@registrations_open Keyword.get(@instance, :registrations_open)

	def user_fetcher(username_or_email) do
	{
	:ok,
	cond do
	# First, try logging in as if it was a name
	user = Repo.get_by(User, %{nickname: username_or_email}) ->
	user

	# If we get nil, we try using it as an email
	user = Repo.get_by(User, %{email: username_or_email}) ->
	user
	end
	}
	end

	pipeline :api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.AuthenticationPlug, %{fetcher: &Router.user_fetcher/1, optional: true})
	end

	pipeline :authenticated_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.AuthenticationPlug, %{fetcher: &Router.user_fetcher/1})
	end

	pipeline :mastodon_html do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.AuthenticationPlug, %{fetcher: &Router.user_fetcher/1, optional: true})
	end

	pipeline :pleroma_html do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.AuthenticationPlug, %{fetcher: &Router.user_fetcher/1, optional: true})
	end

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

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

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

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

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_api)
	get("/password_reset/:token", UtilController, :show_password_reset)
	post("/password_reset", UtilController, :password_reset)
	get("/emoji", UtilController, :emoji)
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:api)
	get("/instance", MastodonAPIController, :masto_instance)
	get("/instance/peers", MastodonAPIController, :peers)
	post("/apps", MastodonAPIController, :create_app)
	get("/custom_emojis", MastodonAPIController, :custom_emojis)

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

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

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

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

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

	scope "/api/v2", Pleroma.Web.MastodonAPI do
	pipe_through(:api)
	get("/search", MastodonAPIController, :search2)
	end

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

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

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

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

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

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

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

	scope "/api", Pleroma.Web do
	if @public do
	pipe_through(:api)
	else
	pipe_through(:authenticated_api)
	end

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

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

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

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

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

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

	post(
	"/account/most_recent_notification",
	TwitterAPI.Controller,
	:update_most_recent_notification
	)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	end

	if @federating do
	+ if @allow_relay do
	+ scope "/relay", Pleroma.Web.ActivityPub do
	+ pipe_through(:ap_relay)
	+ get("/", ActivityPubController, :relay)
	+ end
	+ end
	+
	scope "/", Pleroma.Web.ActivityPub do
	pipe_through(:activitypub)
	post("/users/:nickname/inbox", ActivityPubController, :inbox)
	post("/inbox", ActivityPubController, :inbox)
	end

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

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

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

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

	get("/web/login", MastodonAPIController, :login)
	post("/web/login", MastodonAPIController, :login_post)
	get("/web/*path", MastodonAPIController, :index)
	delete("/auth/sign_out", MastodonAPIController, :logout)
	end

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

	scope "/proxy/", Pleroma.Web.MediaProxy do
	pipe_through(:remote_media)
	get("/:sig/:url", MediaProxyController, :remote)
	end

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

	defmodule Fallback.RedirectController do
	use Pleroma.Web, :controller

	def redirector(conn, _params) do
	if Mix.env() != :test do
	conn
	\|> put_resp_content_type("text/html")
	\|> send_file(200, "priv/static/index.html")
	end
	end

	def registration_page(conn, params) do
	redirector(conn, params)
	end
	end
	diff --git a/test/user_test.exs b/test/user_test.exs
	index 352a16687..5c61b0930 100644
	--- a/test/user_test.exs
	+++ b/test/user_test.exs
	@@ -1,510 +1,510 @@
	defmodule Pleroma.UserTest do
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.{User, Repo, Activity}
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.Websub.WebsubClientSubscription
	alias Pleroma.Web.CommonAPI
	use Pleroma.DataCase

	import Pleroma.Factory
	import Ecto.Query

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build()

	expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

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

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

	followed = User.get_by_ap_id(followed.ap_id)
	assert followed.info["follower_count"] == 1

	assert User.ap_followers(followed) in user.following
	end

	test "can't follow a deactivated users" do
	user = insert(:user)
	followed = insert(:user, info: %{"deactivated" => true})

	{:error, _} = User.follow(user, followed)
	end

	test "can't follow a user who blocked us" do
	blocker = insert(:user)
	blockee = insert(:user)

	{:ok, blocker} = User.block(blocker, blockee)

	{:error, _} = User.follow(blockee, blocker)
	end

	# This is a somewhat useless test.
	# test "following a remote user will ensure a websub subscription is present" do
	# user = insert(:user)
	# {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")

	# assert followed.local == false

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

	# query = from w in WebsubClientSubscription,
	# where: w.topic == ^followed.info["topic"]
	# websub = Repo.one(query)

	# assert websub
	# end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	{:ok, user, _activity} = User.unfollow(user, followed)

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

	assert user.following == []
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

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

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	test "it requires an email, name, nickname and password, bio is optional" do
	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it sets the password_hash, ap_id and following fields" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})

	assert changeset.changes[:following] == [
	User.ap_followers(%User{nickname: @full_user_data.nickname})
	]

	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	fetched_user = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	fetched_user = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "fetches an external user via ostatus if no user exists" do
	fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
	assert fetched_user.nickname == "shp@social.heldscal.la"
	end

	test "returns nil if no user could be fetched" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
	assert fetched_user == nil
	end

	test "returns nil for nonexistant local user" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == nil
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)

	assert User.ap_id(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)

	assert User.ap_followers(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	) <> "/followers"
	end

	describe "remote user creation changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	info: %{some: "info"},
	avatar: %{some: "avatar"}
	}

	test "it confirms validity" do
	cs = User.remote_user_creation(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_adress" do
	cs = User.remote_user_creation(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address ==
	User.ap_followers(%User{nickname: @valid_remote[:nickname]})
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_creation(%{@valid_remote \| nickname: "bla"})
	assert cs.changes.local == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	- [:name, :nickname, :ap_id]
	+ [:name, :ap_id]
	\|> Enum.each(fn field ->
	cs = User.remote_user_creation(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end

	test "it restricts some sizes" do
	[bio: 5000, name: 100]
	\|> Enum.each(fn {field, size} ->
	string = String.pad_leading(".", size)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	assert cs.valid?

	string = String.pad_leading(".", size + 1)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	refute cs.valid?
	end)
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" 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)

	{:ok, res} = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" 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)

	{:ok, res} = User.get_friends(user)

	followed_one = User.get_by_ap_id(followed_one.ap_id)
	followed_two = User.get_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the info->note_count property" do
	note = insert(:note)

	user = User.get_by_ap_id(note.data["actor"])

	assert user.info["note_count"] == nil

	{:ok, user} = User.update_note_count(user)

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

	test "it increases the info->note_count property" do
	note = insert(:note)
	user = User.get_by_ap_id(note.data["actor"])

	assert user.info["note_count"] == nil

	{:ok, user} = User.increase_note_count(user)

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

	{:ok, user} = User.increase_note_count(user)

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

	test "it decreases the info->note_count property" do
	note = insert(:note)
	user = User.get_by_ap_id(note.data["actor"])

	assert user.info["note_count"] == nil

	{:ok, user} = User.increase_note_count(user)

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

	{:ok, user} = User.decrease_note_count(user)

	assert user.info["note_count"] == 0

	{:ok, user} = User.decrease_note_count(user)

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

	test "it sets the info->follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.info["follower_count"] == nil

	{:ok, user} = User.update_follower_count(user)

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

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

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

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

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

	refute User.blocks?(user, blocked_user)
	end

	test "blocks tear down cyclical follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

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

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

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = Repo.get(User, blocked.id)

	assert User.blocks?(blocker, blocked)

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

	test "blocks tear down blocker->blocked follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

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

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

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = Repo.get(User, blocked.id)

	assert User.blocks?(blocker, blocked)

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

	test "blocks tear down blocked->blocker follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

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

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

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = Repo.get(User, blocked.id)

	assert User.blocks?(blocker, blocked)

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

	describe "domain blocking" do
	test "blocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	assert User.blocks?(user, collateral_user)
	end

	test "unblocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
	{:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end
	end

	test "get recipients from activity" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	"status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
	})

	assert [addressed] == User.get_recipients_from_activity(activity)

	{:ok, user} = User.follow(user, actor)
	{:ok, _user_two} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 2
	assert user in recipients
	assert addressed in recipients
	end

	test ".deactivate deactivates a user" do
	user = insert(:user)
	assert false == !!user.info["deactivated"]
	{:ok, user} = User.deactivate(user)
	assert true == user.info["deactivated"]
	end

	test ".delete deactivates a user, all follow relationships and all create activities" do
	user = insert(:user)
	followed = insert(:user)
	follower = insert(:user)

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

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

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

	:ok = User.delete(user)

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

	assert user.info["deactivated"]

	refute User.following?(user, followed)
	refute User.following?(followed, follower)

	# TODO: Remove favorites, repeats, delete activities.

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

	test "get_public_key_for_ap_id fetches a user that's not in the db" do
	assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	test "insert or update a user from given data" do
	user = insert(:user, %{nickname: "nick@name.de"})
	data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}

	assert {:ok, %User{}} = User.insert_or_update_user(data)
	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 3a035e298..87bcdaf71 100644
	--- a/test/web/twitter_api/twitter_api_controller_test.exs
	+++ b/test/web/twitter_api/twitter_api_controller_test.exs
	@@ -1,1083 +1,1084 @@
	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."})
	+ # we post with visibility private in order to avoid triggering relay
	+ conn = conn_with_creds \|> post(request_path, %{status: "Nice meme.", visibility: "private"})

	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, 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 "GET /api/qvitter/mutes.json" do
	setup [:valid_user]

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

	test "unimplemented mutes with credentials", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/mutes.json")

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

	assert [] = json_response(conn, 200)
	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

	test "with credentials, invalid param", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/wrong.json")

	assert json_response(conn, 400)
	end

	test "with credentials, invalid activity", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/1.json")

	assert json_response(conn, 500)
	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/statuses/unretweet/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/statuses/unretweet/#{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)

	request_path = String.replace(request_path, "retweet", "unretweet")

	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
	\|> assign(:user, user)
	\|> 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
	\|> assign(:user, user)
	\|> 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

	test "it locks an account", %{conn: conn} do
	user = insert(:user)

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

	user = Repo.get!(User, user.id)
	assert user.info["locked"] == true

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

	test "it unlocks an account", %{conn: conn} do
	user = insert(:user)

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

	user = Repo.get!(User, user.id)
	assert user.info["locked"] == false

	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"}
	# Wait a second for the started task to end
	:timer.sleep(1000)
	end
	end

	describe "GET /api/pleroma/friend_requests" do
	test "it lists friend requests" do
	user = insert(:user, %{info: %{"locked" => true}})
	other_user = insert(:user)

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

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

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

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

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

	describe "POST /api/pleroma/friendships/approve" do
	test "it approves a friend request" do
	user = insert(:user, %{info: %{"locked" => true}})
	other_user = insert(:user)

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

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

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/pleroma/friendships/approve", %{"user_id" => to_string(other_user.id)})

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

	describe "POST /api/pleroma/friendships/deny" do
	test "it denies a friend request" do
	user = insert(:user, %{info: %{"locked" => true}})
	other_user = insert(:user)

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

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

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/pleroma/friendships/deny", %{"user_id" => to_string(other_user.id)})

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

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 7:30 AM (11 h, 42 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802801
Default Alt Text: (145 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions