No OneTemporary
Actions

Size

76 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/formatter.ex b/lib/pleroma/formatter.ex
	index 8b736797b..fdf91f56e 100644
	--- a/lib/pleroma/formatter.ex
	+++ b/lib/pleroma/formatter.ex
	@@ -1,140 +1,146 @@
	defmodule Pleroma.Formatter do
	alias Pleroma.User
	alias Pleroma.Web.MediaProxy

	@link_regex ~r/https?:\/\/[\w\.\/?=\-#%&@~]+[\w\/]/u
	def linkify(text) do
	Regex.replace(@link_regex, text, "<a href='\\0'>\\0</a>")
	end

	@tag_regex ~r/\#\w+/u
	def parse_tags(text, data \\ %{}) do
	Regex.scan(@tag_regex, text)
	\|> Enum.map(fn (["#" <> tag = full_tag]) -> {full_tag, String.downcase(tag)} end)
	\|> (fn map -> if data["sensitive"] in [true, "True", "true", "1"], do: [{"#nsfw", "nsfw"}] ++ map, else: map end).()
	end

	def parse_mentions(text) do
	# Modified from https://www.w3.org/TR/html5/forms.html#valid-e-mail-address
	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])?)/u

	Regex.scan(regex, text)
	\|> List.flatten
	\|> Enum.uniq
	\|> Enum.map(fn ("@" <> match = full_match) -> {full_match, User.get_cached_by_nickname(match)} end)
	\|> Enum.filter(fn ({_match, user}) -> user end)
	end

	def html_escape(text) do
	Regex.split(@link_regex, text, include_captures: true)
	\|> Enum.map_every(2, fn chunk ->
	{:safe, part} = Phoenix.HTML.html_escape(chunk)
	part
	end)
	\|> Enum.join("")
	end

	@finmoji [
	"a_trusted_friend",
	"alandislands",
	"association",
	"auroraborealis",
	"baby_in_a_box",
	"bear",
	"black_gold",
	"christmasparty",
	"crosscountryskiing",
	"cupofcoffee",
	"education",
	"fashionista_finns",
	"finnishlove",
	"flag",
	"forest",
	"four_seasons_of_bbq",
	"girlpower",
	"handshake",
	"happiness",
	"headbanger",
	"icebreaker",
	"iceman",
	"joulutorttu",
	"kaamos",
	"kalsarikannit_f",
	"kalsarikannit_m",
	"karjalanpiirakka",
	"kicksled",
	"kokko",
	"lavatanssit",
	"losthopes_f",
	"losthopes_m",
	"mattinykanen",
	"meanwhileinfinland",
	"moominmamma",
	"nordicfamily",
	"out_of_office",
	"peacemaker",
	"perkele",
	"pesapallo",
	"polarbear",
	"pusa_hispida_saimensis",
	"reindeer",
	"sami",
	"sauna_f",
	"sauna_m",
	"sauna_whisk",
	"sisu",
	"stuck",
	"suomimainittu",
	"superfood",
	"swan",
	"the_cap",
	"the_conductor",
	"the_king",
	"the_voice",
	"theoriginalsanta",
	"tomoffinland",
	"torillatavataan",
	"unbreakable",
	"waiting",
	"white_nights",
	"woollysocks"
	]

	@finmoji_with_filenames Enum.map(@finmoji, fn (finmoji) ->
	{finmoji, "/finmoji/128px/#{finmoji}-128.png"}
	end)

	- @emoji_from_file (with {:ok, file} <- File.read("config/emoji.txt") do
	- file
	- \|> String.trim
	- \|> String.split("\n")
	- \|> Enum.map(fn(line) ->
	- [name, file] = String.split(line, ", ")
	- {name, file}
	+ @emoji_from_file (with {:ok, default} <- File.read("config/emoji.txt") do
	+ custom =
	+ with {:ok, custom} <- File.read("config/custom_emoji.txt") do
	+ custom
	+ else
	+ _e -> ""
	+ end
	+ (default <> "\n" <> custom)
	+ \|> String.trim()
	+ \|> String.split(~r/\n+/)
	+ \|> Enum.map(fn(line) ->
	+ [name, file] = String.split(line, ~r/,\s*/)
	+ {name, file}
	end)
	else
	_ -> []
	end)

	@emoji @finmoji_with_filenames ++ @emoji_from_file

	def emojify(text, additional \\ nil) do
	all_emoji = if additional do
	Map.to_list(additional) ++ @emoji
	else
	@emoji
	end

	Enum.reduce(all_emoji, text, fn ({emoji, file}, text) ->
	String.replace(text, ":#{emoji}:", "<img height='32px' width='32px' alt='#{emoji}' title='#{emoji}' src='#{MediaProxy.url(file)}' />")
	end)
	end

	def get_emoji(text) do
	Enum.filter(@emoji, fn ({emoji, _}) -> String.contains?(text, ":#{emoji}:") end)
	end

	def get_custom_emoji() do
	@emoji
	end
	end
	diff --git a/lib/pleroma/web/endpoint.ex b/lib/pleroma/web/endpoint.ex
	index b57cf3917..725d2ee64 100644
	--- a/lib/pleroma/web/endpoint.ex
	+++ b/lib/pleroma/web/endpoint.ex
	@@ -1,56 +1,56 @@
	defmodule Pleroma.Web.Endpoint do
	use Phoenix.Endpoint, otp_app: :pleroma

	socket "/socket", Pleroma.Web.UserSocket
	socket "/api/v1", Pleroma.Web.MastodonAPI.MastodonSocket

	# Serve at "/" the static files from "priv/static" directory.
	#
	# You should set gzip to true if you are running phoenix.digest
	# when deploying your static files in production.
	plug Plug.Static,
	at: "/media", from: "uploads", gzip: false
	plug Plug.Static,
	at: "/", from: :pleroma,
	- only: ~w(index.html static finmoji emoji packs sounds sw.js)
	+ only: ~w(index.html static finmoji emoji packs sounds instance sw.js)

	# Code reloading can be explicitly enabled under the
	# :code_reloader configuration of your endpoint.
	if code_reloading? do
	plug Phoenix.CodeReloader
	end

	plug TrailingFormatPlug
	plug Plug.RequestId
	plug Plug.Logger

	plug Plug.Parsers,
	parsers: [:urlencoded, :multipart, :json],
	pass: ["/"],
	json_decoder: Poison

	plug Plug.MethodOverride
	plug Plug.Head

	# The session will be stored in the cookie and signed,
	# this means its contents can be read but not tampered with.
	# Set :encryption_salt if you would also like to encrypt it.
	plug Plug.Session,
	store: :cookie,
	key: "_pleroma_key",
	signing_salt: "CqaoopA2"

	plug Pleroma.Web.Router

	@doc """
	Dynamically loads configuration from the system environment
	on startup.

	It receives the endpoint configuration from the config files
	and must return the updated configuration.
	"""
	def load_from_system_env(config) do
	port = System.get_env("PORT") \|\| raise "expected the PORT environment variable to be set"
	{:ok, Keyword.put(config, :http, [:inet6, port: port])}
	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 0615ac11a..e16a2a092 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	@@ -1,628 +1,629 @@
	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
	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} = Repo.update(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} <- Repo.update(change) do
	user
	else
	_e -> user
	end
	else
	user
	end

	with changeset <- User.update_changeset(user, params),
	{:ok, user} <- Repo.update(changeset) do
	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)

	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: Keyword.get(@instance, :version),
	email: Keyword.get(@instance, :email),
	urls: %{
	streaming_api: String.replace(Web.base_url, ["http","https"], "wss")
	},
	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) do
	last = List.last(activities)
	first = List.first(activities)
	if last do
	min = last.id
	max = first.id
	next_url = mastodon_api_url(Pleroma.Web.Endpoint, method, max_id: min)
	prev_url = mastodon_api_url(Pleroma.Web.Endpoint, method, since_id: max)
	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)

	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

	# TODO: Link headers
	def user_statuses(%{assigns: %{user: user}} = conn, params) do
	with %User{ap_id: ap_id} <- Repo.get(User, params["id"]) do
	params = params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("actor_id", ap_id)
	\|> Map.put("whole_db", true)

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

	render conn, 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) 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["object"]["context"], %{"blocking_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)

	{:ok, activity} = CommonAPI.post(user, params)
	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 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, Poison.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, Poison.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

	# TODO: Link headers
	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
	\|> 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, Poison.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, Poison.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,
	"object" => follow_activity.data["id"] # get latest Follow for these users
	}) 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, Poison.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, Poison.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
	else
	_e -> []
	end
	end \|\| []

	q = from a in Activity,
	where: fragment("?->>'type' = 'Create'", a.data),
	where: fragment("to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)", a.data, ^query),
	limit: 20
	statuses = Repo.all(q) ++ fetched

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

	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 = conn
	\|> Map.put("type", "Create")
	\|> Map.put("favorited_by", user.ap_id)
	\|> Map.put("blocking_user", user)

	activities = ActivityPub.fetch_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: %{
	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
	} \|> Poison.encode!
	conn
	\|> put_layout(false)
	\|> render(MastodonView, "index.html", %{initial_state: initial_state})
	else
	conn
	\|> redirect(to: "/web/login")
	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_cached_by_nickname(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 render_notification(user, %{id: id, activity: activity, inserted_at: created_at} = _params) do
	actor = User.get_cached_by_ap_id(activity.data["actor"])
	created_at = NaiveDateTime.to_iso8601(created_at)
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	case activity.data["type"] do
	"Create" ->
	%{id: id, type: "mention", created_at: created_at, account: AccountView.render("account.json", %{user: actor}), status: StatusView.render("status.json", %{activity: activity, for: user})}
	"Like" ->
	liked_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
	%{id: id, type: "favourite", created_at: created_at, account: AccountView.render("account.json", %{user: actor}), status: StatusView.render("status.json", %{activity: liked_activity, for: user})}
	"Announce" ->
	announced_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
	%{id: id, type: "reblog", created_at: created_at, account: AccountView.render("account.json", %{user: actor}), status: StatusView.render("status.json", %{activity: announced_activity, for: user})}
	"Follow" ->
	%{id: id, type: "follow", created_at: created_at, account: AccountView.render("account.json", %{user: actor})}
	_ -> nil
	end
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index 63dbd6245..6e9f40955 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,277 +1,278 @@
	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router

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

	def user_fetcher(username) do
	{:ok, Repo.get_by(User, %{nickname: username})}
	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, ["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
	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

	post "/follows", MastodonAPIController, :follow

	get "/blocks", MastodonAPIController, :blocks

	get "/domain_blocks", MastodonAPIController, :empty_array
	get "/follow_requests", MastodonAPIController, :empty_array
	get "/mutes", MastodonAPIController, :empty_array

	get "/timelines/home", MastodonAPIController, :home_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/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
	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 "/statuses/:id", MastodonAPIController, :get_status
	get "/statuses/:id/context", MastodonAPIController, :get_context
	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 "/search", MastodonAPIController, :search
	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

	@instance Application.get_env(:pleroma, :instance)
	@registrations_open Keyword.get(@instance, :registrations_open)

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

	get "/statuses/public_timeline", TwitterAPI.Controller, :public_timeline
	get "/statuses/public_and_external_timeline", TwitterAPI.Controller, :public_and_external_timeline
	get "/statuses/networkpublic_timeline", TwitterAPI.Controller, :public_and_external_timeline
	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

	if @registrations_open do
	post "/account/register", TwitterAPI.Controller, :register
	end

	get "/search", TwitterAPI.Controller, :search
	get "/statusnet/tags/timeline/:tag", 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

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

	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 "/externalprofile/show", TwitterAPI.Controller, :external_profile
	end

	pipeline :ostatus do
	plug :accepts, ["xml", "atom", "html"]
	end

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

	get "/objects/:uuid", OStatus.OStatusController, :object
	get "/activities/:uuid", OStatus.OStatusController, :activity
	get "/notice/:id", OStatus.OStatusController, :notice

	get "/users/:nickname/feed", OStatus.OStatusController, :feed
	get "/users/:nickname", OStatus.OStatusController, :feed_redirect
	post "/users/:nickname/salmon", OStatus.OStatusController, :salmon_incoming
	post "/push/hub/:nickname", Websub.WebsubController, :websub_subscription_request
	get "/push/subscriptions/:id", Websub.WebsubController, :websub_subscription_confirmation
	post "/push/subscriptions/:id", Websub.WebsubController, :websub_incoming
	end

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

	get "/host-meta", WebFinger.WebFingerController, :host_meta
	get "/webfinger", WebFinger.WebFingerController, :webfinger
	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 "/*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
	end
	diff --git a/lib/pleroma/web/templates/twitter_api/util/subscribe.html.eex b/lib/pleroma/web/templates/twitter_api/util/subscribe.html.eex
	new file mode 100644
	index 000000000..f60accebf
	--- /dev/null
	+++ b/lib/pleroma/web/templates/twitter_api/util/subscribe.html.eex
	@@ -0,0 +1,10 @@
	+<%= if @error do %>
	+ <h2>Error: <%= @error %></h2>
	+<% else %>
	+ <h2>Remotely follow <%= @nickname %></h2>
	+ <%= form_for @conn, util_path(@conn, :remote_subscribe), [as: "user"], fn f -> %>
	+ <%= hidden_input f, :nickname, value: @nickname %>
	+ <%= text_input f, :profile, placeholder: "Your account ID, e.g. lain@quitter.se" %>
	+ <%= submit "Follow" %>
	+ <% end %>
	+<% end %>
	diff --git a/lib/pleroma/web/twitter_api/controllers/util_controller.ex b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	index a1d56e3ab..0b7c64015 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,145 +1,166 @@
	defmodule Pleroma.Web.TwitterAPI.UtilController do
	use Pleroma.Web, :controller
	require Logger
	alias Pleroma.Web
	alias Pleroma.Web.OStatus
	+ alias Pleroma.Web.WebFinger
	alias Comeonin.Pbkdf2
	alias Pleroma.Formatter
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.{Repo, PasswordResetToken, User}

	def show_password_reset(conn, %{"token" => token}) do
	with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}),
	%User{} = user <- Repo.get(User, token.user_id) do
	render conn, "password_reset.html", %{
	token: token,
	user: user
	}
	else
	_e -> render conn, "invalid_token.html"
	end
	end

	def password_reset(conn, %{"data" => data}) do
	with {:ok, _} <- PasswordResetToken.reset_password(data["token"], data) do
	render conn, "password_reset_success.html"
	else
	_e -> render conn, "password_reset_failed.html"
	end
	end

	def help_test(conn, _params) do
	json(conn, "ok")
	end

	+ def remote_subscribe(conn, %{"nickname" => nick, "profile" => _}) do
	+ with %User{} = user <- User.get_cached_by_nickname(nick),
	+ avatar = User.avatar_url(user) do
	+ conn
	+ \|> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
	+ else
	+ _e -> render(conn, "subscribe.html", %{nickname: nick, avatar: nil, error: "Could not find user"})
	+ end
	+ end
	+ def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
	+ with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	+ %User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
	+ conn
	+ \|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	+ else
	+ _e ->
	+ render(conn, "subscribe.html", %{nickname: nick, avatar: nil, error: "Something went wrong."})
	+ end
	+ end
	+
	def remote_follow(%{assigns: %{user: user}} = conn, %{"acct" => acct}) do
	{err, followee} = OStatus.find_or_make_user(acct)
	avatar = User.avatar_url(followee)
	name = followee.nickname
	id = followee.id

	if !!user do
	conn
	\|> render("follow.html", %{error: err, acct: acct, avatar: avatar, name: name, id: id})
	else
	conn
	\|> render("follow_login.html", %{error: false, acct: acct, avatar: avatar, name: name, id: id})
	end
	end

	def do_remote_follow(conn, %{"authorization" => %{"name" => username, "password" => password, "id" => id}}) do
	followee = Repo.get(User, id)
	avatar = User.avatar_url(followee)
	name = followee.nickname
	with %User{} = user <- User.get_cached_by_nickname(username),
	true <- Pbkdf2.checkpw(password, user.password_hash),
	%User{} = followed <- Repo.get(User, id),
	{:ok, follower} <- User.follow(user, followee),
	{:ok, _activity} <- ActivityPub.follow(follower, followee) do
	conn
	\|> render("followed.html", %{error: false})
	else
	_e ->
	conn
	\|> render("follow_login.html", %{error: "Wrong username or password", id: id, name: name, avatar: avatar})
	end
	end
	def do_remote_follow(%{assigns: %{user: user}} = conn, %{"user" => %{"id" => id}}) do
	with %User{} = followee <- Repo.get(User, id),
	{:ok, follower} <- User.follow(user, followee),
	{:ok, _activity} <- ActivityPub.follow(follower, followee) do
	conn
	\|> render("followed.html", %{error: false})
	else
	e ->
	Logger.debug("Remote follow failed with error #{inspect e}")
	conn
	\|> render("followed.html", %{error: inspect(e)})
	end
	end

	@instance Application.get_env(:pleroma, :instance)
	def config(conn, _params) do
	case get_format(conn) do
	"xml" ->
	response = """
	<config>
	<site>
	<name>#{Keyword.get(@instance, :name)}</name>
	<site>#{Web.base_url}</site>
	<textlimit>#{Keyword.get(@instance, :limit)}</textlimit>
	<closed>#{!Keyword.get(@instance, :registrations_open)}</closed>
	</site>
	</config>
	"""
	conn
	\|> put_resp_content_type("application/xml")
	\|> send_resp(200, response)
	_ ->
	json(conn, %{
	site: %{
	name: Keyword.get(@instance, :name),
	server: Web.base_url,
	textlimit: Keyword.get(@instance, :limit),
	closed: if(Keyword.get(@instance, :registrations_open), do: "0", else: "1")
	}
	})
	end
	end

	def version(conn, _params) do
	version = Keyword.get(@instance, :version)
	case get_format(conn) do
	"xml" ->
	response = "<version>#{version}</version>"
	conn
	\|> put_resp_content_type("application/xml")
	\|> send_resp(200, response)
	_ -> json(conn, version)
	end
	end

	def emoji(conn, _params) do
	json conn, Enum.into(Formatter.get_custom_emoji(), %{})
	end

	def follow_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
	follow_import(conn, %{"list" => File.read!(listfile.path)})
	end
	def follow_import(%{assigns: %{user: user}} = conn, %{"list" => list}) do
	Task.start(fn ->
	String.split(list)
	\|> Enum.map(fn nick ->
	with %User{} = follower <- User.get_cached_by_ap_id(user.ap_id),
	%User{} = followed <- User.get_or_fetch_by_nickname(nick),
	{:ok, follower} <- User.follow(follower, followed) do
	ActivityPub.follow(follower, followed)
	else
	_e -> Logger.debug "follow_import: following #{nick} failed"
	end
	end)
	end)

	json conn, "job started"
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/views/user_view.ex b/lib/pleroma/web/twitter_api/views/user_view.ex
	index 1b995f42f..f49bcc0fb 100644
	--- a/lib/pleroma/web/twitter_api/views/user_view.ex
	+++ b/lib/pleroma/web/twitter_api/views/user_view.ex
	@@ -1,73 +1,74 @@
	defmodule Pleroma.Web.TwitterAPI.UserView do
	use Pleroma.Web, :view
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MediaProxy

	def render("show.json", %{user: user = %User{}} = assigns) do
	render_one(user, Pleroma.Web.TwitterAPI.UserView, "user.json", assigns)
	end

	def render("index.json", %{users: users, for: user}) do
	render_many(users, Pleroma.Web.TwitterAPI.UserView, "user.json", for: user)
	end

	def render("user.json", %{user: user = %User{}} = assigns) do
	image = User.avatar_url(user) \|> MediaProxy.url()
	{following, follows_you, statusnet_blocking} = if assigns[:for] do
	{
	User.following?(assigns[:for], user),
	User.following?(user, assigns[:for]),
	User.blocks?(assigns[:for], user)
	}
	else
	{false, false, false}
	end

	user_info = User.get_cached_user_info(user)

	data = %{
	"created_at" => user.inserted_at \|> Utils.format_naive_asctime,
	"description" => HtmlSanitizeEx.strip_tags(user.bio),
	"favourites_count" => 0,
	"followers_count" => user_info[:follower_count],
	"following" => following,
	"follows_you" => follows_you,
	"statusnet_blocking" => statusnet_blocking,
	"friends_count" => user_info[:following_count],
	"id" => user.id,
	"name" => user.name,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"rights" => %{},
	"screen_name" => user.nickname,
	"statuses_count" => user_info[:note_count],
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => User.banner_url(user) \|> MediaProxy.url(),
	"background_image" => image_url(user.info["background"]) \|> MediaProxy.url(),
	+ "is_local" => user.local
	}

	if assigns[:token] do
	Map.put(data, "token", assigns[:token])
	else
	data
	end
	end

	def render("short.json", %{user: %User{
	nickname: nickname, id: id, ap_id: ap_id, name: name
	}}) do
	%{
	"fullname" => name,
	"id" => id,
	"ostatus_uri" => ap_id,
	"profile_url" => ap_id,
	"screen_name" => nickname
	}
	end

	defp image_url(%{"url" => [ %{ "href" => href } \| _ ]}), do: href
	defp image_url(_), do: nil
	end
	diff --git a/lib/pleroma/web/web_finger/web_finger.ex b/lib/pleroma/web/web_finger/web_finger.ex
	index 4ae3eab59..95e717b17 100644
	--- a/lib/pleroma/web/web_finger/web_finger.ex
	+++ b/lib/pleroma/web/web_finger/web_finger.ex
	@@ -1,123 +1,125 @@
	defmodule Pleroma.Web.WebFinger do
	@httpoison Application.get_env(:pleroma, :httpoison)

	alias Pleroma.{Repo, User, XmlBuilder}
	alias Pleroma.Web
	alias Pleroma.Web.{XML, Salmon, OStatus}
	require Logger

	def host_meta do
	base_url = Web.base_url
	{
	:XRD, %{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
	{
	:Link, %{rel: "lrdd", type: "application/xrd+xml", template: "#{base_url}/.well-known/webfinger?resource={uri}"}
	}
	}
	\|> XmlBuilder.to_doc
	end

	def webfinger(resource) do
	host = Pleroma.Web.Endpoint.host
	regex = ~r/(acct:)?(?<username>\w+)@#{host}/
	with %{"username" => username} <- Regex.named_captures(regex, resource) do
	user = User.get_by_nickname(username)
	{:ok, represent_user(user)}
	else _e ->
	with user when not is_nil(user) <- User.get_cached_by_ap_id(resource) do
	{:ok, represent_user(user)}
	else _e ->
	{:error, "Couldn't find user"}
	end
	end
	end

	def represent_user(user) do
	{:ok, user} = ensure_keys_present(user)
	{:ok, _private, public} = Salmon.keys_from_pem(user.info["keys"])
	magic_key = Salmon.encode_key(public)
	{
	:XRD, %{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
	[
	{:Subject, "acct:#{user.nickname}@#{Pleroma.Web.Endpoint.host}"},
	{:Alias, user.ap_id},
	{:Link, %{rel: "http://schemas.google.com/g/2010#updates-from", type: "application/atom+xml", href: OStatus.feed_path(user)}},
	{:Link, %{rel: "http://webfinger.net/rel/profile-page", type: "text/html", href: user.ap_id}},
	{:Link, %{rel: "salmon", href: OStatus.salmon_path(user)}},
	{:Link, %{rel: "magic-public-key", href: "data:application/magic-public-key,#{magic_key}"}},
	{:Link, %{rel: "http://ostatus.org/schema/1.0/subscribe", template: OStatus.remote_follow_path()}}
	]
	}
	\|> XmlBuilder.to_doc
	end

	# This seems a better fit in Salmon
	def ensure_keys_present(user) do
	info = user.info \|\| %{}
	if info["keys"] do
	{:ok, user}
	else
	{:ok, pem} = Salmon.generate_rsa_pem
	info = Map.put(info, "keys", pem)
	Repo.update(Ecto.Changeset.change(user, info: info))
	end
	end

	defp webfinger_from_xml(doc) do
	magic_key = XML.string_from_xpath(~s{//Link[@rel="magic-public-key"]/@href}, doc)
	"data:application/magic-public-key," <> magic_key = magic_key
	topic = XML.string_from_xpath(~s{//Link[@rel="http://schemas.google.com/g/2010#updates-from"]/@href}, doc)
	subject = XML.string_from_xpath("//Subject", doc)
	salmon = XML.string_from_xpath(~s{//Link[@rel="salmon"]/@href}, doc)
	+ subscribe_address = XML.string_from_xpath(~s{//Link[@rel="http://ostatus.org/schema/1.0/subscribe"]/@template}, doc)
	data = %{
	"magic_key" => magic_key,
	"topic" => topic,
	"subject" => subject,
	- "salmon" => salmon
	+ "salmon" => salmon,
	+ "subscribe_address" => subscribe_address
	}
	{:ok, data}
	end

	def get_template_from_xml(body) do
	xpath = "//Link[@rel='lrdd' and @type='application/xrd+xml']/@template"
	with doc when doc != :error <- XML.parse_document(body),
	template when template != nil <- XML.string_from_xpath(xpath, doc) do
	{:ok, template}
	end
	end

	def find_lrdd_template(domain) do
	with {:ok, %{status_code: status_code, body: body}} when status_code in 200..299 <- @httpoison.get("http://#{domain}/.well-known/host-meta", [], follow_redirect: true) do
	get_template_from_xml(body)
	else
	_ ->
	with {:ok, %{body: body}} <- @httpoison.get("https://#{domain}/.well-known/host-meta", []) do
	get_template_from_xml(body)
	else
	e -> {:error, "Can't find lrdd template: #{inspect(e)}"}
	end
	end
	end

	def finger(account) do
	domain = with [_name, domain] <- String.split(account, "@") do
	domain
	else _e ->
	URI.parse(account).host
	end

	with {:ok, template} <- find_lrdd_template(domain),
	address <- String.replace(template, "{uri}", URI.encode(account)),
	response <- @httpoison.get(address, ["Accept": "application/xrd+xml"]),
	{:ok, %{status_code: status_code, body: body}} when status_code in 200..299 <- response,
	doc when doc != :error<- XML.parse_document(body),
	{:ok, data} <- webfinger_from_xml(doc) do
	{:ok, data}
	else
	e ->
	Logger.debug(fn -> "Couldn't finger #{account}." end)
	Logger.debug(fn -> inspect(e) end)
	{:error, e}
	end
	end
	end
	diff --git a/priv/static/instance/thumbnail.jpeg b/priv/static/instance/thumbnail.jpeg
	new file mode 100644
	index 000000000..b7e012644
	Binary files /dev/null and b/priv/static/instance/thumbnail.jpeg differ
	diff --git a/test/web/ostatus/ostatus_test.exs b/test/web/ostatus/ostatus_test.exs
	index de01612b3..b27f8cb55 100644
	--- a/test/web/ostatus/ostatus_test.exs
	+++ b/test/web/ostatus/ostatus_test.exs
	@@ -1,364 +1,366 @@
	defmodule Pleroma.Web.OStatusTest do
	use Pleroma.DataCase
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.XML
	alias Pleroma.{Object, Repo, User, Activity}
	import Pleroma.Factory

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

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

	user = User.get_by_ap_id(activity.data["actor"])
	assert user.info["note_count"] == 1
	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["id"] == "tag:gs.example.org:4040,2017-04-23:noticeId=29:objectType=note"
	assert activity.data["published"] == "2017-04-23T14:51:03+00:00"
	assert activity.data["object"]["published"] == "2017-04-23T14:51:03+00:00"
	assert activity.data["context"] == "tag:gs.example.org:4040,2017-04-23:objectType=thread:nonce=f09e22f58abd5c7b"
	assert "http://pleroma.example.org:4000/users/lain3" in activity.data["to"]
	assert activity.data["object"]["emoji"] == %{ "marko" => "marko.png", "reimu" => "reimu.png" }
	assert activity.local == false
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"]["content"] == "@<a href=\"https://gs.archae.me/user/4687\" class=\"h-card u-url p-nickname mention\" title=\"shpbot\">shpbot</a> why not indeed."
	assert activity.data["object"]["inReplyTo"] == "tag:gs.archae.me,2017-04-30:noticeId=778260:objectType=note"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

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

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

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

	test "handle incoming retweets - GS, subscription - local message" do
	incoming = File.read!("test/fixtures/share-gs-local.xml")
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	incoming = incoming
	\|> String.replace("LOCAL_ID", note_activity.data["object"]["id"])
	\|> String.replace("LOCAL_USER", user.ap_id)

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

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

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

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

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]
	assert activity.data["id"] == "tag:mastodon.social,2017-05-03:objectId=4934452:objectType=Status"

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

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

	assert activity.data["type"] == "Like"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == favorited_activity.data["object"]["id"]
	assert activity.data["id"] == "tag:social.heldscal.la,2017-05-05:fave:23211:comment:2061643:2017-05-05T09:12:50+00:00"

	refute activity.local
	assert favorited_activity.data["type"] == "Create"
	assert favorited_activity.data["actor"] == "https://shitposter.club/user/1"
	assert favorited_activity.data["object"]["id"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	refute favorited_activity.local
	end

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

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

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

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

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

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

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

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["inReplyTo"] == "http://pleroma.example.org:4000/objects/55bce8fc-b423-46b1-af71-3759ab4670bc"
	assert "http://pleroma.example.org:4000/users/lain5" in activity.data["to"]
	assert activity.data["object"]["id"] == "tag:gs.example.org:4040,2017-04-25:noticeId=55:objectType=note"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming follows" do
	incoming = File.read!("test/fixtures/follow.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	assert activity.data["type"] == "Follow"
	assert activity.data["id"] == "tag:social.heldscal.la,2017-05-07:subscription:23211:person:44803:2017-05-07T09:54:48+00:00"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == "https://pawoo.net/users/pekorino"
	refute activity.local

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

	assert User.following?(follower, followed)
	end

	describe "new remote user creation" do
	test "returns local users" do
	local_user = insert(:user)
	{:ok, user} = OStatus.find_or_make_user(local_user.ap_id)

	assert user == local_user
	end

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

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

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

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

	assert user == user_again
	end

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

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

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

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

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

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

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

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

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

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

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

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

	assert activity.data["actor"] == "https://shitposter.club/user/1"
	assert activity.data["object"]["id"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	end

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

	test "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{}} = OStatus.insert_or_update_user(data)
	end

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

	assert activity.data["to"] == ["http://localhost:4001/users/atarifrosch@social.stopwatchingus-heidelberg.de/followers", "https://www.w3.org/ns/activitystreams#Public"]
	end
	end
	diff --git a/test/web/twitter_api/views/user_view_test.exs b/test/web/twitter_api/views/user_view_test.exs
	index 3f84e4116..e68230a86 100644
	--- a/test/web/twitter_api/views/user_view_test.exs
	+++ b/test/web/twitter_api/views/user_view_test.exs
	@@ -1,163 +1,167 @@
	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)))

	image = "http://localhost:4001/static/avi.png"
	banner = "http://localhost:4001/static/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" => %{},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	- "background_image" => nil
	+ "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/static/avi.png"
	banner = "http://localhost:4001/static/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" => %{},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	- "background_image" => nil
	+ "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/static/avi.png"
	banner = "http://localhost:4001/static/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" => %{},
	"statusnet_profile_url" => follower.ap_id,
	"cover_photo" => banner,
	- "background_image" => nil
	+ "background_image" => nil,
	+ "is_local" => true
	}

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

	test "A blocked user for the blocker", %{user: user} do
	user = insert(:user)
	blocker = insert(:user)
	User.block(blocker, user)
	image = "http://localhost:4001/static/avi.png"
	banner = "http://localhost:4001/static/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" => %{},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	- "background_image" => nil
	+ "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, Oct 11, 4:08 AM (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1785593
Default Alt Text: (76 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions