No OneTemporary
Actions

Authored By

Unknown

Size

83 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/config/test.exs b/config/test.exs
	index 0c73f892a..1bd11dee4 100644
	--- a/config/test.exs
	+++ b/config/test.exs
	@@ -1,37 +1,37 @@
	use Mix.Config

	# We don't run a server during test. If one is required,
	# you can enable the server option below.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [port: 4001],
	server: false

	# Print only warnings and errors during test
	config :logger, level: :warn

	config :pleroma, Pleroma.Upload, uploads: "test/uploads"

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_test",
	hostname: System.get_env("DB_HOST") \|\| "localhost",
	pool: Ecto.Adapters.SQL.Sandbox

	# Reduce hash rounds for testing
	-config :comeonin, :pbkdf2_rounds, 1
	+config :pbkdf2_elixir, rounds: 1

	config :pleroma, :websub, Pleroma.Web.WebsubMock
	config :pleroma, :ostatus, Pleroma.Web.OStatusMock
	config :pleroma, :httpoison, HTTPoisonMock

	try do
	import_config "test.secret.exs"
	rescue
	_ ->
	IO.puts(
	"You may want to create test.secret.exs to declare custom database connection parameters."
	)
	end
	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index e1e3bcd63..a89728471 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,61 +1,65 @@
	defmodule Pleroma.Application do
	use Application

	# See http://elixir-lang.org/docs/stable/elixir/Application.html
	# for more information on OTP Applications
	def start(_type, _args) do
	import Supervisor.Spec
	+ import Cachex.Spec

	# Define workers and child supervisors to be supervised
	children =
	[
	# Start the Ecto repository
	supervisor(Pleroma.Repo, []),
	# Start the endpoint when the application starts
	supervisor(Pleroma.Web.Endpoint, []),
	# Start your own worker by calling: Pleroma.Worker.start_link(arg1, arg2, arg3)
	# worker(Pleroma.Worker, [arg1, arg2, arg3]),
	worker(Cachex, [
	:user_cache,
	[
	default_ttl: 25000,
	ttl_interval: 1000,
	limit: 2500
	]
	]),
	worker(
	Cachex,
	[
	:idempotency_cache,
	[
	- default_ttl: :timer.seconds(6 * 60 * 60),
	- ttl_interval: :timer.seconds(60),
	+ expiration:
	+ expiration(
	+ default: :timer.seconds(6 * 60 * 60),
	+ interval: :timer.seconds(60)
	+ ),
	limit: 2500
	]
	],
	id: :cachex_idem
	),
	worker(Pleroma.Web.Federator, []),
	worker(Pleroma.Gopher.Server, []),
	worker(Pleroma.Stats, [])
	] ++
	if Mix.env() == :test,
	do: [],
	else:
	[worker(Pleroma.Web.Streamer, [])] ++
	if(
	!chat_enabled(),
	do: [],
	else: [worker(Pleroma.Web.ChatChannel.ChatChannelState, [])]
	)

	# See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
	# for other strategies and supported options
	opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
	Supervisor.start_link(children, opts)
	end

	defp chat_enabled do
	Application.get_env(:pleroma, :chat, []) \|> Keyword.get(:enabled)
	end
	end
	diff --git a/lib/pleroma/object.ex b/lib/pleroma/object.ex
	index 558e151b0..ff2af4a6f 100644
	--- a/lib/pleroma/object.ex
	+++ b/lib/pleroma/object.ex
	@@ -1,55 +1,51 @@
	defmodule Pleroma.Object do
	use Ecto.Schema
	alias Pleroma.{Repo, Object}
	import Ecto.{Query, Changeset}

	schema "objects" do
	field(:data, :map)

	timestamps()
	end

	def create(data) do
	Object.change(%Object{}, %{data: data})
	\|> Repo.insert()
	end

	def change(struct, params \\ %{}) do
	struct
	\|> cast(params, [:data])
	\|> validate_required([:data])
	\|> unique_constraint(:ap_id, name: :objects_unique_apid_index)
	end

	def get_by_ap_id(nil), do: nil

	def get_by_ap_id(ap_id) do
	Repo.one(from(object in Object, where: fragment("(?)->>'id' = ?", object.data, ^ap_id)))
	end

	def get_cached_by_ap_id(ap_id) do
	if Mix.env() == :test do
	get_by_ap_id(ap_id)
	else
	key = "object:#{ap_id}"

	- Cachex.get!(
	- :user_cache,
	- key,
	- fallback: fn _ ->
	- object = get_by_ap_id(ap_id)
	-
	- if object do
	- {:commit, object}
	- else
	- {:ignore, object}
	- end
	+ Cachex.fetch!(:user_cache, key, fn _ ->
	+ object = get_by_ap_id(ap_id)
	+
	+ if object do
	+ {:commit, object}
	+ else
	+ {:ignore, object}
	end
	- )
	+ end)
	end
	end

	def context_mapping(context) do
	Object.change(%Object{}, %{data: %{"id" => context}})
	end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 6a8129ac8..690cc7cf3 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,558 +1,558 @@
	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
	}
	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])
	\|> 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 follow(%User{} = follower, %User{info: info} = followed) do
	ap_followers = followed.follower_address

	if following?(follower, followed) or info["deactivated"] do
	{:error, "Could not follow user: #{followed.nickname} is already on your list."}
	else
	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 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.set(:user_cache, "ap_id:#{user.ap_id}", user)
	- Cachex.set(:user_cache, "nickname:#{user.nickname}", user)
	- Cachex.set(:user_cache, "user_info:#{user.id}", user_info(user))
	+ 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.get!(:user_cache, key, fallback: fn _ -> get_by_ap_id(ap_id) end)
	+ 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.get!(:user_cache, key, fallback: fn _ -> get_or_fetch_by_nickname(nickname) end)
	+ 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.get!(:user_cache, key, fallback: fn _ -> user_info(user) end)
	+ 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 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(%Activity{recipients: to}) do
	query =
	from(
	u in User,
	where: u.ap_id in ^to,
	where: u.local == true
	)

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

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

	Repo.all(q)
	end

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

	cs = User.info_changeset(user, %{info: new_info})
	update_and_set_cache(cs)
	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"] \|\| []
	Enum.member?(blocks, ap_id)
	end

	def local_user_query() do
	from(u in User, where: u.local == true)
	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.get_by_ap_id(activity.data["object"]["id"]))

	# 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

	# 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/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index a31452a63..7d6fd8632 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,529 +1,529 @@
	defmodule Pleroma.Web.ActivityPub.Transmogrifier do
	@moduledoc """
	A module to handle coding from internal to wire ActivityPub and back.
	"""
	alias Pleroma.User
	alias Pleroma.Object
	alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Ecto.Query

	require Logger

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

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

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

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

	def fix_in_reply_to(object), do: object

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	# TODO
	# Accept
	# Undo for non-Announce

	def handle_incoming(_), do: :error

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

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

	def set_reply_to_uri(obj), do: obj

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

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

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

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

	{:ok, data}
	end

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

	{:ok, data}
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	Repo.update_all(q, [])

	maybe_retire_websub(user.ap_id)

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

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

	Repo.update_all(q, [])
	end

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

	already_ap = User.ap_enabled?(user)

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

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

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

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

	Repo.delete_all(q)
	end
	end

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

	def maybe_fix_user_object(data) do
	data
	\|> maybe_fix_user_url
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	index 85f9c5b7b..e6365620e 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	@@ -1,798 +1,794 @@
	defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
	use Pleroma.Web, :controller
	alias Pleroma.{Repo, Activity, User, Notification, Stats}
	alias Pleroma.Web
	alias Pleroma.Web.MastodonAPI.{StatusView, AccountView, MastodonView}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.{CommonAPI, OStatus}
	alias Pleroma.Web.OAuth.{Authorization, Token, App}
	alias Comeonin.Pbkdf2
	import Ecto.Query
	require Logger

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

	json(conn, res)
	end
	end

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

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

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

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

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

	with changeset <- User.update_changeset(user, params),
	{:ok, user} <- User.update_and_set_cache(changeset) do
	if original_user != user do
	CommonAPI.update(user)
	end

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

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

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

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

	def masto_instance(conn, _params) do
	response = %{
	uri: Web.base_url(),
	title: Keyword.get(@instance, :name),
	description: "A Pleroma instance, an alternative fediverse server",
	version: "#{@mastodon_api_level} (compatible; #{Keyword.get(@instance, :version)})",
	email: Keyword.get(@instance, :email),
	urls: %{
	streaming_api: String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws")
	},
	stats: Stats.get_stats(),
	thumbnail: Web.base_url() <> "/instance/thumbnail.jpeg",
	max_toot_chars: Keyword.get(@instance, :limit)
	}

	json(conn, response)
	end

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

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

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

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

	defp add_link_headers(conn, method, activities, param \\ false) do
	last = List.last(activities)
	first = List.first(activities)

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

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

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

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

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

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

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

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

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

	def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
	with %User{} = user <- Repo.get(User, params["id"]) do
	# Since Pleroma has no "pinned" posts feature, we'll just set an empty list here
	activities =
	if params["pinned"] == "true" do
	[]
	else
	ActivityPub.fetch_user_activities(user, reading_user, params)
	end

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

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

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

	json(conn, result)
	end
	end

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

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

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

	render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
	end

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

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

	def unreblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _, _, %{data: %{"id" => id}}} = CommonAPI.unrepeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
	render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
	end
	end

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

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

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

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

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

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

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

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

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

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

	render(conn, StatusView, "attachment.json", %{attachment: data})
	end
	end

	def favourited_by(conn, %{"id" => id}) do
	with %Activity{data: %{"object" => %{"likes" => likes}}} <- Repo.get(Activity, id) do
	q = from(u in User, where: u.ap_id in ^likes)
	users = Repo.all(q)
	render(conn, AccountView, "accounts.json", %{users: users, as: :user})
	else
	_ -> json(conn, [])
	end
	end

	def reblogged_by(conn, %{"id" => id}) do
	with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Repo.get(Activity, id) do
	q = from(u in User, where: u.ap_id in ^announces)
	users = Repo.all(q)
	render(conn, AccountView, "accounts.json", %{users: users, as: :user})
	else
	_ -> json(conn, [])
	end
	end

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

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

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

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

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

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

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

	# TODO: Clean up and unify
	def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
	with %User{} = followed <- Repo.get(User, id),
	{:ok, follower, follow_activity} <- User.unfollow(follower, followed),
	{:ok, _activity} <-
	ActivityPub.insert(%{
	"type" => "Undo",
	"actor" => follower.ap_id,
	# get latest Follow for these users
	"object" => follow_activity.data["id"]
	}) do
	render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
	end
	end

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

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

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

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

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

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

	statuses = Repo.all(q) ++ fetched

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

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

	json(conn, res)
	end

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

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

	json(conn, res)
	end

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

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

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

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

	if user && token do
	mastodon_emoji = mastodonized_emoji()
	accounts = Map.put(%{}, user.id, AccountView.render("account.json", %{user: user}))

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

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

	def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
	with new_info <- Map.put(user.info, "settings", settings),
	change <- User.info_changeset(user, %{info: new_info}),
	{:ok, _user} <- User.update_and_set_cache(change) do
	conn
	\|> json(%{})
	else
	e ->
	conn
	\|> json(%{error: inspect(e)})
	end
	end

	def login(conn, _) do
	conn
	\|> render(MastodonView, "login.html", %{error: false})
	end

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

	Repo.insert(cs)
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	_ ->
	nil
	end
	end
	end
	diff --git a/mix.exs b/mix.exs
	index f49d2d04a..281687294 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,66 +1,67 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: "0.9.0",
	elixir: "~> 1.4",
	elixirc_paths: elixirc_paths(Mix.env()),
	compilers: [:phoenix, :gettext] ++ Mix.compilers(),
	start_permanent: Mix.env() == :prod,
	aliases: aliases(),
	deps: deps()
	]
	end

	# Configuration for the OTP application.
	#
	# Type `mix help compile.app` for more information.
	def application do
	[mod: {Pleroma.Application, []}, extra_applications: [:logger, :runtime_tools, :comeonin]]
	end

	# Specifies which paths to compile per environment.
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	# Specifies your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	[
	{:phoenix, "~> 1.3.0"},
	{:phoenix_pubsub, "~> 1.0"},
	{:phoenix_ecto, "~> 3.2"},
	{:postgrex, ">= 0.0.0"},
	{:gettext, "~> 0.11"},
	{:cowboy, "~> 1.0", override: true},
	- {:comeonin, "~> 3.0"},
	+ {:comeonin, "~> 4.0"},
	+ {:pbkdf2_elixir, "~> 0.12"},
	{:trailing_format_plug, "~> 0.0.5"},
	{:html_sanitize_ex, "~> 1.3.0-rc1"},
	{:phoenix_html, "~> 2.10"},
	{:calendar, "~> 0.16.1"},
	- {:cachex, "~> 2.1"},
	+ {:cachex, "~> 3.0"},
	{:httpoison, "~> 1.1.0"},
	{:jason, "~> 1.0"},
	{:ex_machina, "~> 2.0", only: :test},
	{:credo, "~> 0.7", only: [:dev, :test]},
	{:mock, "~> 0.3.0", only: :test}
	]
	end

	# Aliases are shortcuts or tasks specific to the current project.
	# For example, to create, migrate and run the seeds file at once:
	#
	# $ mix ecto.setup
	#
	# See the documentation for `Mix` for more info on aliases.
	defp aliases do
	[
	"ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
	"ecto.reset": ["ecto.drop", "ecto.setup"],
	test: ["ecto.create --quiet", "ecto.migrate", "test"]
	]
	end
	end
	diff --git a/mix.lock b/mix.lock
	index 1f53df7de..2a826111c 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,48 +1,44 @@
	%{
	"bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm"},
	- "cachex": {:hex, :cachex, "2.1.0", "fad49b4e78d11c6c314e75bd8c9408f5b78cb065c047442798caed10803ee3be", [:mix], [{:eternal, "~> 1.1", [hex: :eternal, repo: "hexpm", optional: false]}], "hexpm"},
	+ "cachex": {:hex, :cachex, "3.0.2", "1351caa4e26e29f7d7ec1d29b53d6013f0447630bbf382b4fb5d5bad0209f203", [:mix], [{:eternal, "~> 1.2", [hex: :eternal, repo: "hexpm", optional: false]}, {:unsafe, "~> 1.0", [hex: :unsafe, repo: "hexpm", optional: false]}], "hexpm"},
	"calendar": {:hex, :calendar, "0.16.1", "782327ad8bae7c797b887840dc4ddb933f05ce6e333e5b04964d7a5d5f79bde3", [:mix], [{:tzdata, "~> 0.5.8 or ~> 0.1.201603", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm"},
	"certifi": {:hex, :certifi, "2.3.1", "d0f424232390bf47d82da8478022301c561cf6445b5b5fb6a84d49a9e76d2639", [:rebar3], [{:parse_trans, "3.2.0", [hex: :parse_trans, repo: "hexpm", optional: false]}], "hexpm"},
	- "comeonin": {:hex, :comeonin, "3.2.0", "cb10995a22aed6812667efb3856f548818c85d85394d8132bc116fbd6995c1ef", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm"},
	- "con_cache": {:hex, :con_cache, "0.12.0", "2d961aec219aa5a914473873f348f5a6088292dc69d5192a9d25f8a1e13e9905", [:mix], [{:exactor, "~> 2.2.0", [hex: :exactor, optional: false]}]},
	+ "comeonin": {:hex, :comeonin, "4.1.1", "c7304fc29b45b897b34142a91122bc72757bc0c295e9e824999d5179ffc08416", [:mix], [{:argon2_elixir, "~> 1.2", [hex: :argon2_elixir, repo: "hexpm", optional: true]}, {:bcrypt_elixir, "~> 0.12.1 or ~> 1.0", [hex: :bcrypt_elixir, repo: "hexpm", optional: true]}, {:pbkdf2_elixir, "~> 0.12", [hex: :pbkdf2_elixir, repo: "hexpm", optional: true]}], "hexpm"},
	"connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm"},
	"cowboy": {:hex, :cowboy, "1.1.2", "61ac29ea970389a88eca5a65601460162d370a70018afe6f949a29dca91f3bb0", [:rebar3], [{:cowlib, "~> 1.0.2", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "~> 1.3.2", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm"},
	"cowlib": {:hex, :cowlib, "1.0.2", "9d769a1d062c9c3ac753096f868ca121e2730b9a377de23dec0f7e08b1df84ee", [:make], [], "hexpm"},
	- "credo": {:hex, :credo, "0.9.1", "f021affa11b32a94dc2e807a6472ce0914289c9132f99644a97fc84432b202a1", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:poison, ">= 0.0.0", [hex: :poison, repo: "hexpm", optional: false]}], "hexpm"},
	+ "credo": {:hex, :credo, "0.9.2", "841d316612f568beb22ba310d816353dddf31c2d94aa488ae5a27bb53760d0bf", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:poison, ">= 0.0.0", [hex: :poison, repo: "hexpm", optional: false]}], "hexpm"},
	"db_connection": {:hex, :db_connection, "1.1.3", "89b30ca1ef0a3b469b1c779579590688561d586694a3ce8792985d4d7e575a61", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, repo: "hexpm", optional: true]}], "hexpm"},
	"decimal": {:hex, :decimal, "1.5.0", "b0433a36d0e2430e3d50291b1c65f53c37d56f83665b43d79963684865beab68", [:mix], [], "hexpm"},
	- "deppie": {:hex, :deppie, "1.1.0", "cfb6fcee7dfb64eb78cb8505537971a0805131899326ad469ef10df04520f451", [:mix], []},
	"ecto": {:hex, :ecto, "2.2.10", "e7366dc82f48f8dd78fcbf3ab50985ceeb11cb3dc93435147c6e13f2cda0992e", [:mix], [{:db_connection, "~> 1.1", [hex: :db_connection, repo: "hexpm", optional: true]}, {:decimal, "~> 1.2", [hex: :decimal, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.8.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: true]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.13.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, repo: "hexpm", optional: true]}], "hexpm"},
	- "elixir_make": {:hex, :elixir_make, "0.4.1", "6628b86053190a80b9072382bb9756a6c78624f208ec0ff22cb94c8977d80060", [:mix], [], "hexpm"},
	"eternal": {:hex, :eternal, "1.2.0", "e2a6b6ce3b8c248f7dc31451aefca57e3bdf0e48d73ae5043229380a67614c41", [:mix], [], "hexpm"},
	"ex_machina": {:hex, :ex_machina, "2.2.0", "fec496331e04fc2db2a1a24fe317c12c0c4a50d2beb8ebb3531ed1f0d84be0ed", [:mix], [{:ecto, "~> 2.1", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm"},
	- "exactor": {:hex, :exactor, "2.2.3", "a6972f43bb6160afeb73e1d8ab45ba604cd0ac8b5244c557093f6e92ce582786", [:mix], []},
	- "fs": {:hex, :fs, "2.12.0", "ad631efacc9a5683c8eaa1b274e24fa64a1b8eb30747e9595b93bec7e492e25e", [:rebar3], []},
	"gettext": {:hex, :gettext, "0.15.0", "40a2b8ce33a80ced7727e36768499fc9286881c43ebafccae6bab731e2b2b8ce", [:mix], [], "hexpm"},
	"hackney": {:hex, :hackney, "1.12.1", "8bf2d0e11e722e533903fe126e14d6e7e94d9b7983ced595b75f532e04b7fdc7", [:rebar3], [{:certifi, "2.3.1", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "5.1.1", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "1.0.1", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "1.0.2", [hex: :mimerl, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "1.1.1", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm"},
	"html_sanitize_ex": {:hex, :html_sanitize_ex, "1.3.0", "f005ad692b717691203f940c686208aa3d8ffd9dd4bb3699240096a51fa9564e", [:mix], [{:mochiweb, "~> 2.15", [hex: :mochiweb, repo: "hexpm", optional: false]}], "hexpm"},
	- "httpoison": {:hex, :httpoison, "1.1.0", "497949fb62924432f64a45269d20e6f61ecf35084ffa270917afcdb7cd4d8061", [:mix], [{:hackney, "~> 1.8", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"},
	+ "httpoison": {:hex, :httpoison, "1.1.1", "96ed7ab79f78a31081bb523eefec205fd2900a02cda6dbc2300e7a1226219566", [:mix], [{:hackney, "~> 1.8", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"},
	"idna": {:hex, :idna, "5.1.1", "cbc3b2fa1645113267cc59c760bafa64b2ea0334635ef06dbac8801e42f7279c", [:rebar3], [{:unicode_util_compat, "0.3.1", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm"},
	"jason": {:hex, :jason, "1.0.0", "0f7cfa9bdb23fed721ec05419bcee2b2c21a77e926bce0deda029b5adc716fe2", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
	"meck": {:hex, :meck, "0.8.9", "64c5c0bd8bcca3a180b44196265c8ed7594e16bcc845d0698ec6b4e577f48188", [:rebar3], [], "hexpm"},
	"metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm"},
	"mime": {:hex, :mime, "1.2.0", "78adaa84832b3680de06f88f0997e3ead3b451a440d183d688085be2d709b534", [:mix], [], "hexpm"},
	"mimerl": {:hex, :mimerl, "1.0.2", "993f9b0e084083405ed8252b99460c4f0563e41729ab42d9074fd5e52439be88", [:rebar3], [], "hexpm"},
	- "mix_test_watch": {:hex, :mix_test_watch, "0.3.3", "70859889a8d1d43d1b75d69d87258a301f43209a17787cdb2bd9cab42adf271d", [:mix], [{:fs, "~> 2.12", [hex: :fs, optional: false]}]},
	"mochiweb": {:hex, :mochiweb, "2.15.0", "e1daac474df07651e5d17cc1e642c4069c7850dc4508d3db7263a0651330aacc", [:rebar3], [], "hexpm"},
	"mock": {:hex, :mock, "0.3.1", "994f00150f79a0ea50dc9d86134cd9ebd0d177ad60bd04d1e46336cdfdb98ff9", [:mix], [{:meck, "~> 0.8.8", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm"},
	"parse_trans": {:hex, :parse_trans, "3.2.0", "2adfa4daf80c14dc36f522cf190eb5c4ee3e28008fc6394397c16f62a26258c2", [:rebar3], [], "hexpm"},
	+ "pbkdf2_elixir": {:hex, :pbkdf2_elixir, "0.12.3", "6706a148809a29c306062862c803406e88f048277f6e85b68faf73291e820b84", [:mix], [], "hexpm"},
	"phoenix": {:hex, :phoenix, "1.3.2", "2a00d751f51670ea6bc3f2ba4e6eb27ecb8a2c71e7978d9cd3e5de5ccf7378bd", [:mix], [{:cowboy, "~> 1.0", [hex: :cowboy, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.0", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.3.3 or ~> 1.4", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: false]}], "hexpm"},
	"phoenix_ecto": {:hex, :phoenix_ecto, "3.3.0", "702f6e164512853d29f9d20763493f2b3bcfcb44f118af2bc37bb95d0801b480", [:mix], [{:ecto, "~> 2.1", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.9", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	- "phoenix_html": {:hex, :phoenix_html, "2.11.1", "77b6f7fbd252168c6ec4f573de648d37cc5258cda13266ef001fbf99267eb6f3", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	+ "phoenix_html": {:hex, :phoenix_html, "2.11.2", "86ebd768258ba60a27f5578bec83095bdb93485d646fc4111db8844c316602d6", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"phoenix_pubsub": {:hex, :phoenix_pubsub, "1.0.2", "bfa7fd52788b5eaa09cb51ff9fcad1d9edfeb68251add458523f839392f034c1", [:mix], [], "hexpm"},
	- "plug": {:hex, :plug, "1.5.0", "224b25b4039bedc1eac149fb52ed456770b9678bbf0349cdd810460e1e09195b", [:mix], [{:cowboy, "~> 1.0.1 or ~> 1.1 or ~> 2.1", [hex: :cowboy, repo: "hexpm", optional: true]}, {:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}], "hexpm"},
	+ "plug": {:hex, :plug, "1.5.1", "1ff35bdecfb616f1a2b1c935ab5e4c47303f866cb929d2a76f0541e553a58165", [:mix], [{:cowboy, "~> 1.0.1 or ~> 1.1 or ~> 2.3", [hex: :cowboy, repo: "hexpm", optional: true]}, {:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}], "hexpm"},
	"poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm"},
	"poolboy": {:hex, :poolboy, "1.5.1", "6b46163901cfd0a1b43d692657ed9d7e599853b3b21b95ae5ae0a777cf9b6ca8", [:rebar], [], "hexpm"},
	"postgrex": {:hex, :postgrex, "0.13.5", "3d931aba29363e1443da167a4b12f06dcd171103c424de15e5f3fc2ba3e6d9c5", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 1.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm"},
	"ranch": {:hex, :ranch, "1.3.2", "e4965a144dc9fbe70e5c077c65e73c57165416a901bd02ea899cfd95aa890986", [:rebar3], [], "hexpm"},
	"ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.1", "28a4d65b7f59893bc2c7de786dec1e1555bd742d336043fe644ae956c3497fbe", [:make, :rebar], [], "hexpm"},
	"trailing_format_plug": {:hex, :trailing_format_plug, "0.0.7", "64b877f912cf7273bed03379936df39894149e35137ac9509117e59866e10e45", [:mix], [{:plug, "> 0.12.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"tzdata": {:hex, :tzdata, "0.5.16", "13424d3afc76c68ff607f2df966c0ab4f3258859bbe3c979c9ed1606135e7352", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"},
	"unicode_util_compat": {:hex, :unicode_util_compat, "0.3.1", "a1f612a7b512638634a603c8f401892afbf99b8ce93a45041f8aaca99cadb85e", [:rebar3], [], "hexpm"},
	+ "unsafe": {:hex, :unsafe, "1.0.0", "7c21742cd05380c7875546b023481d3a26f52df8e5dfedcb9f958f322baae305", [:mix], [], "hexpm"},
	}
	diff --git a/test/web/twitter_api/views/notification_view_test.exs b/test/web/twitter_api/views/notification_view_test.exs
	index e3b140657..79eafda7d 100644
	--- a/test/web/twitter_api/views/notification_view_test.exs
	+++ b/test/web/twitter_api/views/notification_view_test.exs
	@@ -1,108 +1,108 @@
	defmodule Pleroma.Web.TwitterAPI.NotificationViewTest do
	use Pleroma.DataCase

	alias Pleroma.{User, Notification}
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.NotificationView
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Builders.UserBuilder

	import Pleroma.Factory

	setup do
	user = insert(:user, bio: "<span>Here's some html</span>")
	[user: user]
	end

	test "A follow notification" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	follower = insert(:user)

	{:ok, follower} = User.follow(follower, user)
	{:ok, activity} = ActivityPub.follow(follower, user)
	- Cachex.set(:user_cache, "user_info:#{user.id}", User.user_info(Repo.get!(User, user.id)))
	+ Cachex.put(:user_cache, "user_info:#{user.id}", User.user_info(Repo.get!(User, user.id)))
	[follow_notif] = Notification.for_user(user)

	represented = %{
	"created_at" => follow_notif.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: follower, for: user}),
	"id" => follow_notif.id,
	"is_seen" => 0,
	"notice" => ActivityView.render("activity.json", %{activity: activity, for: user}),
	"ntype" => "follow"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: follow_notif, for: user})
	end

	test "A mention notification" do
	user = insert(:user)
	other_user = insert(:user)

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

	[notification] = Notification.for_user(user)

	represented = %{
	"created_at" => notification.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: other_user, for: user}),
	"id" => notification.id,
	"is_seen" => 0,
	"notice" => ActivityView.render("activity.json", %{activity: activity, for: user}),
	"ntype" => "mention"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: notification, for: user})
	end

	test "A retweet notification" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	repeater = insert(:user)

	{:ok, activity} = TwitterAPI.repeat(repeater, note_activity.id)
	[notification] = Notification.for_user(user)

	represented = %{
	"created_at" => notification.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: repeater, for: user}),
	"id" => notification.id,
	"is_seen" => 0,
	"notice" =>
	ActivityView.render("activity.json", %{activity: notification.activity, for: user}),
	"ntype" => "repeat"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: notification, for: user})
	end

	test "A like notification" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	liker = insert(:user)

	{:ok, activity} = TwitterAPI.fav(liker, note_activity.id)
	[notification] = Notification.for_user(user)

	represented = %{
	"created_at" => notification.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: liker, for: user}),
	"id" => notification.id,
	"is_seen" => 0,
	"notice" =>
	ActivityView.render("activity.json", %{activity: notification.activity, for: user}),
	"ntype" => "like"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: notification, for: user})
	end
	end
	diff --git a/test/web/twitter_api/views/user_view_test.exs b/test/web/twitter_api/views/user_view_test.exs
	index dd55c0b7e..9f8bf4cdc 100644
	--- a/test/web/twitter_api/views/user_view_test.exs
	+++ b/test/web/twitter_api/views/user_view_test.exs
	@@ -1,182 +1,182 @@
	defmodule Pleroma.Web.TwitterAPI.UserViewTest do
	use Pleroma.DataCase

	alias Pleroma.User
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Builders.UserBuilder

	import Pleroma.Factory

	setup do
	user = insert(:user, bio: "<span>Here's some html</span>")
	[user: user]
	end

	test "A user with an avatar object", %{user: user} do
	image = "image"
	user = %{user \| avatar: %{"url" => [%{"href" => image}]}}
	represented = UserView.render("show.json", %{user: user})
	assert represented["profile_image_url"] == image
	end

	test "A user" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	{:ok, user} = User.update_note_count(user)
	follower = insert(:user)
	second_follower = insert(:user)

	User.follow(follower, user)
	User.follow(second_follower, user)
	User.follow(user, follower)
	{:ok, user} = User.update_follower_count(user)
	- Cachex.set(:user_cache, "user_info:#{user.id}", User.user_info(Repo.get!(User, user.id)))
	+ Cachex.put(:user_cache, "user_info:#{user.id}", User.user_info(Repo.get!(User, user.id)))

	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => user.id,
	"name" => user.name,
	"screen_name" => user.nickname,
	"description" => HtmlSanitizeEx.strip_tags(user.bio),
	"created_at" => user.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 1,
	"friends_count" => 1,
	"followers_count" => 2,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => false,
	"follows_you" => false,
	"statusnet_blocking" => false,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true
	}

	assert represented == UserView.render("show.json", %{user: user})
	end

	test "A user for a given other follower", %{user: user} do
	{:ok, follower} = UserBuilder.insert(%{following: [User.ap_followers(user)]})
	{:ok, user} = User.update_follower_count(user)
	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => user.id,
	"name" => user.name,
	"screen_name" => user.nickname,
	"description" => HtmlSanitizeEx.strip_tags(user.bio),
	"created_at" => user.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 0,
	"friends_count" => 0,
	"followers_count" => 1,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => true,
	"follows_you" => false,
	"statusnet_blocking" => false,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true
	}

	assert represented == UserView.render("show.json", %{user: user, for: follower})
	end

	test "A user that follows you", %{user: user} do
	follower = insert(:user)
	{:ok, follower} = User.follow(follower, user)
	{:ok, user} = User.update_follower_count(user)
	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => follower.id,
	"name" => follower.name,
	"screen_name" => follower.nickname,
	"description" => HtmlSanitizeEx.strip_tags(follower.bio),
	"created_at" => follower.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 0,
	"friends_count" => 1,
	"followers_count" => 0,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => false,
	"follows_you" => true,
	"statusnet_blocking" => false,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => follower.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true
	}

	assert represented == UserView.render("show.json", %{user: follower, for: user})
	end

	test "a user that is a moderator" do
	user = insert(:user, %{info: %{"is_moderator" => true}})
	represented = UserView.render("show.json", %{user: user, for: user})

	assert represented["rights"]["delete_others_notice"]
	end

	test "A blocked user for the blocker" do
	user = insert(:user)
	blocker = insert(:user)
	User.block(blocker, user)
	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => user.id,
	"name" => user.name,
	"screen_name" => user.nickname,
	"description" => HtmlSanitizeEx.strip_tags(user.bio),
	"created_at" => user.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 0,
	"friends_count" => 0,
	"followers_count" => 0,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => false,
	"follows_you" => false,
	"statusnet_blocking" => true,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true
	}

	blocker = Repo.get(User, blocker.id)
	assert represented == UserView.render("show.json", %{user: user, for: blocker})
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 2:36 AM (16 h, 36 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802262
Default Alt Text: (83 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions