No OneTemporary
Actions

Authored By

Unknown

Size

65 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index b43235d8d..0a0aea966 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,222 +1,224 @@
	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 :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 "/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

	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

	get "/notifications", MastodonAPIController, :notifications

	post "/media", MastodonAPIController, :upload
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through :api
	get "/instance", MastodonAPIController, :masto_instance
	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 "/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 "/statuses/followers", TwitterAPI.Controller, :followers
	get "/statuses/friends", TwitterAPI.Controller, :friends

	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 "/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 "/", 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/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index 912d5e278..baa3dac96 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,309 +1,329 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
	alias Pleroma.{User, Activity, Repo, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.{OStatus, CommonAPI}
	alias Pleroma.Formatter
	import Ecto.Query

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

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

	def fetch_friend_statuses(user, opts \\ %{}) do
	opts = Map.put(opts, "blocking_user", user)
	ActivityPub.fetch_activities([user.ap_id \| user.following], opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_public_statuses(user, opts \\ %{}) do
	opts = Map.put(opts, "local_only", true)
	opts = Map.put(opts, "blocking_user", user)
	ActivityPub.fetch_public_activities(opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_public_and_external_statuses(user, opts \\ %{}) do
	opts = Map.put(opts, "blocking_user", user)
	ActivityPub.fetch_public_activities(opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_user_statuses(user, opts \\ %{}) do
	ActivityPub.fetch_activities([], opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_mentions(user, opts \\ %{}) do
	ActivityPub.fetch_activities([user.ap_id], opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_conversation(user, id) do
	with context when is_binary(context) <- conversation_id_to_context(id),
	activities <- ActivityPub.fetch_activities_for_context(context, %{"blocking_user" => user}),
	statuses <- activities \|> activities_to_statuses(%{for: user})
	do
	statuses
	else _e ->
	[]
	end
	end

	def fetch_status(user, id) do
	with %Activity{} = activity <- Repo.get(Activity, id) do
	activity_to_status(activity, %{for: user})
	end
	end

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

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

	+ def block(%User{} = blocker, params) do
	+ with {:ok, %User{} = blocked} <- get_user(params),
	+ {:ok, blocker} <- User.block(blocker, blocked)
	+ do
	+ {:ok, blocker, blocked}
	+ else
	+ err -> err
	+ end
	+ end
	+
	+ def unblock(%User{} = blocker, params) do
	+ with {:ok, %User{} = blocked} <- get_user(params),
	+ {:ok, blocker} <- User.unblock(blocker, blocked)
	+ do
	+ {:ok, blocker, blocked}
	+ else
	+ err -> err
	+ end
	+ end
	+
	def repeat(%User{} = user, ap_id_or_id) do
	with {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id),
	status <- activity_to_status(activity, %{for: user}) do
	{:ok, status}
	end
	end

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

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

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

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

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

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

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

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

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

	def get_user(user \\ nil, params) do
	case params do
	%{"user_id" => user_id} ->
	case target = get_by_id_or_nickname(user_id) do
	nil ->
	{:error, "No user with such user_id"}
	_ ->
	{:ok, target}
	end
	%{"screen_name" => nickname} ->
	case target = Repo.get_by(User, nickname: nickname) do
	nil ->
	{:error, "No user with such screen_name"}
	_ ->
	{:ok, target}
	end
	_ ->
	if user do
	{:ok, user}
	else
	{:error, "You need to specify screen_name or user_id"}
	end
	end
	end

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

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

	q = from a in Activity,
	where: fragment("?->>'type' = 'Create'", a.data),
	where: fragment("to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)", a.data, ^query),
	limit: ^limit,
	offset: ^offset,
	order_by: [desc: :inserted_at] # this one isn't indexed so psql won't take the wrong index.

	activities = Repo.all(q)
	activities_to_statuses(activities, %{for: user})
	end

	defp activities_to_statuses(activities, opts) do
	Enum.map(activities, fn(activity) ->
	activity_to_status(activity, opts)
	end)
	end

	# For likes, fetch the liked activity, too.
	defp activity_to_status(%Activity{data: %{"type" => "Like"}} = activity, opts) do
	actor = get_in(activity.data, ["actor"])
	user = User.get_cached_by_ap_id(actor)
	[liked_activity] = Activity.all_by_object_ap_id(activity.data["object"])

	ActivityRepresenter.to_map(activity, Map.merge(opts, %{user: user, liked_activity: liked_activity}))
	end

	# For announces, fetch the announced activity and the user.
	defp activity_to_status(%Activity{data: %{"type" => "Announce"}} = activity, opts) do
	actor = get_in(activity.data, ["actor"])
	user = User.get_cached_by_ap_id(actor)
	[announced_activity] = Activity.all_by_object_ap_id(activity.data["object"])
	announced_actor = User.get_cached_by_ap_id(announced_activity.data["actor"])

	ActivityRepresenter.to_map(activity, Map.merge(opts, %{users: [user, announced_actor], announced_activity: announced_activity}))
	end

	defp activity_to_status(%Activity{data: %{"type" => "Delete"}} = activity, opts) do
	actor = get_in(activity.data, ["actor"])
	user = User.get_cached_by_ap_id(actor)
	ActivityRepresenter.to_map(activity, Map.merge(opts, %{user: user}))
	end

	defp activity_to_status(activity, opts) do
	actor = get_in(activity.data, ["actor"])
	user = User.get_cached_by_ap_id(actor)
	# mentioned_users = Repo.all(from user in User, where: user.ap_id in ^activity.data["to"])
	mentioned_users = Enum.map(activity.data["to"] \|\| [], fn (ap_id) ->
	if ap_id do
	User.get_cached_by_ap_id(ap_id)
	else
	nil
	end
	end)
	\|> Enum.filter(&(&1))

	ActivityRepresenter.to_map(activity, Map.merge(opts, %{user: user, mentioned: mentioned_users}))
	end

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

	def context_to_conversation_id(context) do
	with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
	id
	else _e ->
	changeset = Object.context_mapping(context)
	case Repo.insert(changeset) do
	{:ok, %{id: id}} -> id
	# This should be solved by an upsert, but it seems ecto
	# has problems accessing the constraint inside the jsonb.
	{:error, _} -> Object.get_cached_by_ap_id(context).id
	end
	end
	end

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

	def get_external_profile(for_user, uri) do
	with {:ok, %User{} = user} <- OStatus.find_or_make_user(uri) do
	with url <- user.info["topic"],
	{:ok, %{body: body}} <- @httpoison.get(url, [], follow_redirect: true, timeout: 10000, recv_timeout: 20000) do
	OStatus.handle_incoming(body)
	end
	{:ok, UserView.render("show.json", %{user: user, for: for_user})}
	else _e ->
	{:error, "Couldn't find user"}
	end
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api_controller.ex b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	index 6154d5ad7..2604b54dc 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	@@ -1,293 +1,309 @@
	defmodule Pleroma.Web.TwitterAPI.Controller do
	use Pleroma.Web, :controller
	alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView}
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	alias Pleroma.Web.CommonAPI
	alias Pleroma.{Repo, Activity, User, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Ecto.Changeset

	require Logger

	def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
	render(conn, UserView, "show.json", %{user: user})
	end

	def status_update(%{assigns: %{user: user}} = conn, %{"status" => status_text} = status_data) do
	with media_ids <- extract_media_ids(status_data),
	{:ok, activity} <- TwitterAPI.create_status(user, Map.put(status_data, "media_ids", media_ids)) do
	conn
	\|> json(ActivityRepresenter.to_map(activity, %{user: user}))
	else
	_ -> empty_status_reply(conn)
	end
	end

	def status_update(conn, _status_data) do
	empty_status_reply(conn)
	end

	defp empty_status_reply(conn) do
	bad_request_reply(conn, "Client must provide a 'status' parameter with a value.")
	end

	defp extract_media_ids(status_data) do
	with media_ids when not is_nil(media_ids) <- status_data["media_ids"],
	split_ids <- String.split(media_ids, ","),
	clean_ids <- Enum.reject(split_ids, fn (id) -> String.length(id) == 0 end)
	do
	clean_ids
	else _e -> []
	end
	end

	def public_and_external_timeline(%{assigns: %{user: user}} = conn, params) do
	statuses = TwitterAPI.fetch_public_and_external_statuses(user, params)
	{:ok, json} = Poison.encode(statuses)

	conn
	\|> json_reply(200, json)
	end

	def public_timeline(%{assigns: %{user: user}} = conn, params) do
	statuses = TwitterAPI.fetch_public_statuses(user, params)
	{:ok, json} = Poison.encode(statuses)

	conn
	\|> json_reply(200, json)
	end

	def friends_timeline(%{assigns: %{user: user}} = conn, params) do
	statuses = TwitterAPI.fetch_friend_statuses(user, params)
	{:ok, json} = Poison.encode(statuses)

	conn
	\|> json_reply(200, json)
	end

	def user_timeline(%{assigns: %{user: user}} = conn, params) do
	case TwitterAPI.get_user(user, params) do
	{:ok, target_user} ->
	params = Map.merge(params, %{"actor_id" => target_user.ap_id})
	statuses = TwitterAPI.fetch_user_statuses(user, params)
	conn
	\|> json_reply(200, statuses \|> Poison.encode!)
	{:error, msg} ->
	bad_request_reply(conn, msg)
	end
	end

	def mentions_timeline(%{assigns: %{user: user}} = conn, params) do
	statuses = TwitterAPI.fetch_mentions(user, params)
	{:ok, json} = Poison.encode(statuses)

	conn
	\|> json_reply(200, json)
	end

	def follow(%{assigns: %{user: user}} = conn, params) do
	case TwitterAPI.follow(user, params) do
	{:ok, user, followed, _activity} ->
	render(conn, UserView, "show.json", %{user: followed, for: user})
	{:error, msg} -> forbidden_json_reply(conn, msg)
	end
	end

	+ def block(%{assigns: %{user: user}} = conn, params) do
	+ case TwitterAPI.block(user, params) do
	+ {:ok, user, blocked} ->
	+ render conn, UserView, "show.json", %{user: blocked, for: user}
	+ {:error, msg} -> forbidden_json_reply(conn, msg)
	+ end
	+ end
	+
	+ def unblock(%{assigns: %{user: user}} = conn, params) do
	+ case TwitterAPI.unblock(user, params) do
	+ {:ok, user, blocked} ->
	+ render conn, UserView, "show.json", %{user: blocked, for: user}
	+ {:error, msg} -> forbidden_json_reply(conn, msg)
	+ end
	+ end
	+
	def delete_post(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, delete} <- CommonAPI.delete(id, user) do
	json = ActivityRepresenter.to_json(delete, %{user: user, for: user})
	conn
	\|> json_reply(200, json)
	end
	end

	def unfollow(%{assigns: %{user: user}} = conn, params) do
	case TwitterAPI.unfollow(user, params) do
	{:ok, user, unfollowed} ->
	render(conn, UserView, "show.json", %{user: unfollowed, for: user})
	{:error, msg} -> forbidden_json_reply(conn, msg)
	end
	end

	def fetch_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	response = Poison.encode!(TwitterAPI.fetch_status(user, id))

	conn
	\|> json_reply(200, response)
	end

	def fetch_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	id = String.to_integer(id)
	response = Poison.encode!(TwitterAPI.fetch_conversation(user, id))

	conn
	\|> json_reply(200, response)
	end

	def upload(conn, %{"media" => media}) do
	response = TwitterAPI.upload(media)
	conn
	\|> put_resp_content_type("application/atom+xml")
	\|> send_resp(200, response)
	end

	def upload_json(conn, %{"media" => media}) do
	response = TwitterAPI.upload(media, "json")
	conn
	\|> json_reply(200, response)
	end

	def get_by_id_or_ap_id(id) do
	activity = Repo.get(Activity, id) \|\| Activity.get_create_activity_by_object_ap_id(id)
	if activity.data["type"] == "Create" do
	activity
	else
	Activity.get_create_activity_by_object_ap_id(activity.data["object"])
	end
	end

	def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, status} <- TwitterAPI.fav(user, id) do
	json(conn, status)
	end
	end

	def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, status} <- TwitterAPI.unfav(user, id) do
	json(conn, status)
	end
	end

	def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, status} <- TwitterAPI.repeat(user, id) do
	json(conn, status)
	end
	end

	def register(conn, params) do
	with {:ok, user} <- TwitterAPI.register_user(params) do
	render(conn, UserView, "show.json", %{user: user})
	else
	{:error, errors} ->
	conn
	\|> json_reply(400, Poison.encode!(errors))
	end
	end

	def update_avatar(%{assigns: %{user: user}} = conn, params) do
	{:ok, object} = ActivityPub.upload(params)
	change = Changeset.change(user, %{avatar: object.data})
	{:ok, user} = Repo.update(change)

	render(conn, UserView, "show.json", %{user: user, for: user})
	end

	def update_banner(%{assigns: %{user: user}} = conn, params) do
	with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}),
	new_info <- Map.put(user.info, "banner", object.data),
	change <- User.info_changeset(user, %{info: new_info}),
	{:ok, user} <- Repo.update(change) do
	%{"url" => [ %{ "href" => href } \| t ]} = object.data
	response = %{ url: href } \|> Poison.encode!
	conn
	\|> json_reply(200, response)
	end
	end

	def update_background(%{assigns: %{user: user}} = conn, params) do
	with {:ok, object} <- ActivityPub.upload(params),
	new_info <- Map.put(user.info, "background", object.data),
	change <- User.info_changeset(user, %{info: new_info}),
	{:ok, user} <- Repo.update(change) do
	%{"url" => [ %{ "href" => href } \| t ]} = object.data
	response = %{ url: href } \|> Poison.encode!
	conn
	\|> json_reply(200, response)
	end
	end

	def external_profile(%{assigns: %{user: current_user}} = conn, %{"profileurl" => uri}) do
	with {:ok, user_map} <- TwitterAPI.get_external_profile(current_user, uri),
	response <- Poison.encode!(user_map) do
	conn
	\|> json_reply(200, response)
	else
	_e ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Can't find user"})
	end
	end

	def update_most_recent_notification(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with id when is_number(id) <- String.to_integer(id),
	info <- user.info,
	mrn <- max(id, user.info["most_recent_notification"] \|\| 0),
	updated_info <- Map.put(info, "most_recent_notification", mrn),
	changeset <- User.info_changeset(user, %{info: updated_info}),
	{:ok, user} <- Repo.update(changeset) do
	conn
	\|> json_reply(200, Poison.encode!(mrn))
	else
	_e -> bad_request_reply(conn, "Can't update.")
	end
	end

	def followers(%{assigns: %{user: user}} = conn, _params) do
	with {:ok, followers} <- User.get_followers(user) do
	render(conn, UserView, "index.json", %{users: followers, for: user})
	else
	_e -> bad_request_reply(conn, "Can't get followers")
	end
	end

	def friends(%{assigns: %{user: user}} = conn, _params) do
	with {:ok, friends} <- User.get_friends(user) do
	render(conn, UserView, "index.json", %{users: friends, for: user})
	else
	_e -> bad_request_reply(conn, "Can't get friends")
	end
	end

	def update_profile(%{assigns: %{user: user}} = conn, params) do
	params = if bio = params["description"] do
	Map.put(params, "bio", bio)
	else
	params
	end

	with changeset <- User.update_changeset(user, params),
	{:ok, user} <- Repo.update(changeset) do
	render(conn, UserView, "user.json", %{user: user, for: user})
	else
	error ->
	Logger.debug("Can't update user: #{inspect(error)}")
	bad_request_reply(conn, "Can't update user")
	end
	end

	def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	conn
	\|> json(TwitterAPI.search(user, params))
	end

	defp bad_request_reply(conn, error_message) do
	json = error_json(conn, error_message)
	json_reply(conn, 400, json)
	end

	defp json_reply(conn, status, json) do
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(status, json)
	end

	defp forbidden_json_reply(conn, error_message) do
	json = error_json(conn, error_message)
	json_reply(conn, 403, json)
	end

	defp error_json(conn, error_message) do
	%{"error" => error_message, "request" => conn.request_path} \|> Poison.encode!
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_controller_test.exs b/test/web/twitter_api/twitter_api_controller_test.exs
	index 798309f7d..6bdf29a13 100644
	--- a/test/web/twitter_api/twitter_api_controller_test.exs
	+++ b/test/web/twitter_api/twitter_api_controller_test.exs
	@@ -1,511 +1,554 @@
	defmodule Pleroma.Web.TwitterAPI.ControllerTest do
	use Pleroma.Web.ConnCase
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	alias Pleroma.Builders.{ActivityBuilder, UserBuilder}
	alias Pleroma.{Repo, Activity, User, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

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

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

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

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

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

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

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

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

	error_response = %{"request" => request_path,
	"error" => "Client must provide a 'status' parameter with a value."}
	conn = conn_with_creds \|> post(request_path)
	assert json_response(conn, 400) == error_response

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

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

	conn = conn_with_creds \|> post(request_path, %{ status: "Nice meme." })
	assert json_response(conn, 200) == ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
	end
	end

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

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

	response = json_response(conn, 200)

	assert length(response) == 10
	end
	end

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

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

	response = json_response(conn, 200)

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

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

	{:ok, object} = Object.context_mapping("2hu") \|> Repo.insert
	conn = conn
	\|> get("/api/statusnet/conversation/#{object.id}.json")

	response = json_response(conn, 200)

	assert length(response) == 2
	end
	end

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

	test "with credentials", %{conn: conn, user: current_user} do
	user = insert(:user)
	activities = ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})
	returned_activities = ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})
	other_user = insert(:user)
	ActivityBuilder.insert_list(10, %{}, %{user: other_user})
	since_id = List.last(activities).id

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

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

	response = json_response(conn, 200)

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

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

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

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

	response = json_response(conn, 200)

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

	describe "GET /statuses/user_timeline.json" do
	setup [:valid_user]
	test "without any params", %{conn: conn} do
	conn = get(conn, "/api/statuses/user_timeline.json")
	assert json_response(conn, 400) == %{"error" => "You need to specify screen_name or user_id", "request" => "/api/statuses/user_timeline.json"}
	end

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

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

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

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

	test "with credentials", %{conn: conn, user: current_user} do
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
	conn = conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json")

	response = json_response(conn, 200)

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

	test "with credentials with user_id", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
	conn = conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

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

	test "with credentials screen_name", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
	conn = conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})

	response = json_response(conn, 200)

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

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

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

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

	current_user = Repo.get(User, current_user.id)
	assert current_user.following == [User.ap_followers(followed)]
	assert json_response(conn, 200) == UserView.render("show.json", %{user: followed, for: current_user})
	end
	end

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

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

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

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

	current_user = Repo.get(User, current_user.id)
	assert current_user.following == []
	assert json_response(conn, 200) == UserView.render("show.json", %{user: followed, for: current_user})
	end
	end

	+ describe "POST /blocks/create.json" do
	+ setup [:valid_user]
	+ test "without valid credentials", %{conn: conn} do
	+ conn = post conn, "/api/blocks/create.json"
	+ assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	+ end
	+
	+ test "with credentials", %{conn: conn, user: current_user} do
	+ blocked = insert(:user)
	+
	+ conn = conn
	+ \|> with_credentials(current_user.nickname, "test")
	+ \|> post("/api/blocks/create.json", %{user_id: blocked.id})
	+
	+ current_user = Repo.get(User, current_user.id)
	+ assert User.blocks?(current_user, blocked)
	+ assert json_response(conn, 200) == UserView.render("show.json", %{user: blocked, for: current_user})
	+ end
	+ end
	+
	+ describe "POST /blocks/destroy.json" do
	+ setup [:valid_user]
	+ test "without valid credentials", %{conn: conn} do
	+ conn = post conn, "/api/blocks/destroy.json"
	+ assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	+ end
	+
	+ test "with credentials", %{conn: conn, user: current_user} do
	+ blocked = insert(:user)
	+
	+ {:ok, current_user} = User.block(current_user, blocked)
	+ assert User.blocks?(current_user, blocked)
	+
	+ conn = conn
	+ \|> with_credentials(current_user.nickname, "test")
	+ \|> post("/api/blocks/destroy.json", %{user_id: blocked.id})
	+
	+ current_user = Repo.get(User, current_user.id)
	+ assert current_user.info["blocks"] == []
	+ assert json_response(conn, 200) == UserView.render("show.json", %{user: blocked, for: current_user})
	+ end
	+ end
	+
	describe "GET /help/test.json" do
	test "returns \"ok\"", %{conn: conn} do
	conn = get conn, "/api/help/test.json"
	assert json_response(conn, 200) == "ok"
	end
	end

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

	test "with credentials", %{conn: conn, user: current_user} do
	conn = conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/update_avatar.json", %{img: Pleroma.Web.ActivityPub.ActivityPubTest.data_uri})

	current_user = Repo.get(User, current_user.id)
	assert is_map(current_user.avatar)
	assert json_response(conn, 200) == UserView.render("show.json", %{user: current_user, for: current_user})
	end
	end

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

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

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

	assert json_response(conn, 200)
	end
	end

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

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

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

	assert json_response(conn, 200)
	end
	end

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

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

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

	response = conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)
	activity = Repo.get(Activity, note_activity.id)
	activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])
	assert json_response(response, 200) == ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
	end
	end

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

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

	user = json_response(conn, 200)

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

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

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

	errors = json_response(conn, 400)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert [status] = json_response(conn, 200)
	assert status["id"] == activity.id
	end
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index 1ec9ef388..994cc8f90 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,374 +1,408 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	alias Pleroma.Builders.{UserBuilder, ActivityBuilder}
	alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView}
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.{Activity, User, Object, Repo}
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Pleroma.Factory

	test "create a status" do
	user = insert(:user)
	_mentioned_user = UserBuilder.insert(%{nickname: "shp", ap_id: "shp"})

	object_data = %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}

	object = Repo.insert!(%Object{data: object_data})

	input = %{
	"status" => "Hello again, @shp.<script></script>\nThis is on another line. #2hu #epic #phantasmagoric",
	"media_ids" => [object.id]
	}

	{ :ok, activity = %Activity{} } = TwitterAPI.create_status(user, input)

	assert get_in(activity.data, ["object", "content"]) == "Hello again, <a href='shp'>@shp</a>.<br>\nThis is on another line. #2hu #epic #phantasmagoric<br>\n<a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"
	assert get_in(activity.data, ["object", "type"]) == "Note"
	assert get_in(activity.data, ["object", "actor"]) == user.ap_id
	assert get_in(activity.data, ["actor"]) == user.ap_id
	assert Enum.member?(get_in(activity.data, ["to"]), User.ap_followers(user))
	assert Enum.member?(get_in(activity.data, ["to"]), "https://www.w3.org/ns/activitystreams#Public")
	assert Enum.member?(get_in(activity.data, ["to"]), "shp")
	assert activity.local == true

	# hashtags
	assert activity.data["object"]["tag"] == ["2hu", "epic", "phantasmagoric"]

	# Add a context
	assert is_binary(get_in(activity.data, ["context"]))
	assert is_binary(get_in(activity.data, ["object", "context"]))

	assert is_list(activity.data["object"]["attachment"])

	assert activity.data["object"] == Object.get_by_ap_id(activity.data["object"]["id"]).data

	user = User.get_by_ap_id(user.ap_id)

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

	test "create a status that is a reply" do
	user = insert(:user)
	input = %{
	"status" => "Hello again."
	}

	{ :ok, activity = %Activity{} } = TwitterAPI.create_status(user, input)

	input = %{
	"status" => "Here's your (you).",
	"in_reply_to_status_id" => activity.id
	}

	{ :ok, reply = %Activity{} } = TwitterAPI.create_status(user, input)

	assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])
	assert get_in(reply.data, ["object", "context"]) == get_in(activity.data, ["object", "context"])
	assert get_in(reply.data, ["object", "inReplyTo"]) == get_in(activity.data, ["object", "id"])
	assert get_in(reply.data, ["object", "inReplyToStatusId"]) == activity.id
	assert Enum.member?(get_in(reply.data, ["to"]), user.ap_id)
	end

	test "fetch public statuses, excluding remote ones." do
	%{ public: activity, user: user } = ActivityBuilder.public_and_non_public
	insert(:note_activity, %{local: false})

	follower = insert(:user, following: [User.ap_followers(user)])

	statuses = TwitterAPI.fetch_public_statuses(follower)

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

	test "fetch whole known network statuses" do
	%{ public: activity, user: user } = ActivityBuilder.public_and_non_public
	insert(:note_activity, %{local: false})

	follower = insert(:user, following: [User.ap_followers(user)])

	statuses = TwitterAPI.fetch_public_and_external_statuses(follower)

	assert length(statuses) == 2
	assert Enum.at(statuses, 0) == ActivityRepresenter.to_map(activity, %{user: user, for: follower})
	end

	test "fetch friends' statuses" do
	user = insert(:user, %{following: ["someguy/followers"]})
	{:ok, activity} = ActivityBuilder.insert(%{"to" => ["someguy/followers"]})
	{:ok, direct_activity} = ActivityBuilder.insert(%{"to" => [user.ap_id]})

	statuses = TwitterAPI.fetch_friend_statuses(user)

	activity_user = Repo.get_by(User, ap_id: activity.data["actor"])
	direct_activity_user = Repo.get_by(User, ap_id: direct_activity.data["actor"])

	assert length(statuses) == 2
	assert Enum.at(statuses, 0) == ActivityRepresenter.to_map(activity, %{user: activity_user})
	assert Enum.at(statuses, 1) == ActivityRepresenter.to_map(direct_activity, %{user: direct_activity_user, mentioned: [user]})
	end

	test "fetch user's mentions" do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"to" => [user.ap_id]})
	activity_user = Repo.get_by(User, ap_id: activity.data["actor"])

	statuses = TwitterAPI.fetch_mentions(user)

	assert length(statuses) == 1
	assert Enum.at(statuses, 0) == ActivityRepresenter.to_map(activity, %{user: activity_user, mentioned: [user]})
	end

	test "get a user by params" do
	user1_result = {:ok, user1} = UserBuilder.insert(%{ap_id: "some id", email: "test@pleroma"})
	{:ok, user2} = UserBuilder.insert(%{ap_id: "some other id", nickname: "testname2", email: "test2@pleroma"})

	assert {:error, "You need to specify screen_name or user_id"} == TwitterAPI.get_user(nil, nil)
	assert user1_result == TwitterAPI.get_user(nil, %{"user_id" => user1.id})
	assert user1_result == TwitterAPI.get_user(nil, %{"user_id" => user1.nickname})
	assert user1_result == TwitterAPI.get_user(nil, %{"screen_name" => user1.nickname})
	assert user1_result == TwitterAPI.get_user(user1, nil)
	assert user1_result == TwitterAPI.get_user(user2, %{"user_id" => user1.id})
	assert user1_result == TwitterAPI.get_user(user2, %{"screen_name" => user1.nickname})
	assert {:error, "No user with such screen_name"} == TwitterAPI.get_user(nil, %{"screen_name" => "Satan"})
	assert {:error, "No user with such user_id"} == TwitterAPI.get_user(nil, %{"user_id" => 666})
	end

	test "fetch user's statuses" do
	{:ok, user1} = UserBuilder.insert(%{ap_id: "some id", email: "test@pleroma"})
	{:ok, user2} = UserBuilder.insert(%{ap_id: "some other id", nickname: "testname2", email: "test2@pleroma"})

	{:ok, status1} = ActivityBuilder.insert(%{"id" => 1}, %{user: user1})
	{:ok, status2} = ActivityBuilder.insert(%{"id" => 2}, %{user: user2})

	user1_statuses = TwitterAPI.fetch_user_statuses(user1, %{"actor_id" => user1.ap_id})

	assert length(user1_statuses) == 1
	assert Enum.at(user1_statuses, 0) == ActivityRepresenter.to_map(status1, %{user: user1})

	user2_statuses = TwitterAPI.fetch_user_statuses(user1, %{"actor_id" => user2.ap_id})

	assert length(user2_statuses) == 1
	assert Enum.at(user2_statuses, 0) == ActivityRepresenter.to_map(status2, %{user: user2})
	end

	test "fetch a single status" do
	{:ok, activity} = ActivityBuilder.insert()
	{:ok, user} = UserBuilder.insert()
	actor = Repo.get_by!(User, ap_id: activity.data["actor"])

	status = TwitterAPI.fetch_status(user, activity.id)

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

	test "Follow another user using user_id" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity } = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert user.following == [User.ap_followers(followed)]

	{ :error, msg } = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Follow another user using screen_name" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity } = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
	assert user.following == [User.ap_followers(followed)]

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

	{ :error, msg } = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Unfollow another user using user_id" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed } = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert user.following == []

	{ :error, msg } = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert msg == "Not subscribed!"
	end

	test "Unfollow another user using screen_name" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})

	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed } = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert user.following == []

	{ :error, msg } = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert msg == "Not subscribed!"
	end

	+ test "Block another user using user_id" do
	+ user = insert(:user)
	+ blocked = insert(:user)
	+
	+ {:ok, user, blocked} = TwitterAPI.block(user, %{"user_id" => blocked.id})
	+ assert User.blocks?(user, blocked)
	+ end
	+
	+ test "Block another user using screen_name" do
	+ user = insert(:user)
	+ blocked = insert(:user)
	+
	+ {:ok, user, blocked} = TwitterAPI.block(user, %{"screen_name" => blocked.nickname})
	+ assert User.blocks?(user, blocked)
	+ end
	+
	+ test "Unblock another user using user_id" do
	+ unblocked = insert(:user)
	+ user = insert(:user)
	+ User.block(user, unblocked)
	+
	+ {:ok, user, unblocked} = TwitterAPI.unblock(user, %{"user_id" => unblocked.id})
	+ assert user.info["blocks"] == []
	+ end
	+
	+ test "Unblock another user using screen_name" do
	+ unblocked = insert(:user)
	+ user = insert(:user)
	+ User.block(user, unblocked)
	+
	+ {:ok, user, unblocked} = TwitterAPI.unblock(user, %{"screen_name" => unblocked.nickname})
	+ assert user.info["blocks"] == []
	+ end
	+
	test "fetch statuses in a context using the conversation id" do
	{:ok, user} = UserBuilder.insert()
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})

	{:ok, object} = Object.context_mapping("2hu") \|> Repo.insert

	statuses = TwitterAPI.fetch_conversation(user, object.id)

	assert length(statuses) == 2
	assert Enum.at(statuses, 1)["id"] == activity.id
	assert Enum.at(statuses, 0)["id"] == activity_two.id
	end

	test "upload a file" do
	file = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}

	response = TwitterAPI.upload(file)

	assert is_binary(response)
	end

	test "it adds user links to an existing text" do
	text = "@gsimg According to @archaeme, that is @daggsy. Also hello @archaeme@archae.me"

	gsimg = insert(:user, %{nickname: "gsimg"})
	archaeme = insert(:user, %{nickname: "archaeme"})
	archaeme_remote = insert(:user, %{nickname: "archaeme@archae.me"})

	mentions = Pleroma.Formatter.parse_mentions(text)
	expected_text = "<a href='#{gsimg.ap_id}'>@gsimg</a> According to <a href='#{archaeme.ap_id}'>@archaeme</a>, that is @daggsy. Also hello <a href='#{archaeme_remote.ap_id}'>@archaeme</a>"

	assert Utils.add_user_links(text, mentions) == expected_text
	end

	test "it favorites a status, returns the updated status" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	activity_user = Repo.get_by!(User, ap_id: note_activity.data["actor"])

	{:ok, status} = TwitterAPI.fav(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == ActivityRepresenter.to_map(updated_activity, %{user: activity_user, for: user})
	end

	test "it unfavorites a status, returns the updated status" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	activity_user = Repo.get_by!(User, ap_id: note_activity.data["actor"])
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, _like_activity, _object } = ActivityPub.like(user, object)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
	assert ActivityRepresenter.to_map(updated_activity, %{user: activity_user, for: user})["fave_num"] == 1

	{:ok, status} = TwitterAPI.unfav(user, note_activity.id)

	assert status["fave_num"] == 0
	end

	test "it retweets a status and returns the retweet" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	activity_user = Repo.get_by!(User, ap_id: note_activity.data["actor"])

	{:ok, status} = TwitterAPI.repeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == ActivityRepresenter.to_map(updated_activity, %{user: activity_user, for: user})
	end

	test "it registers a new user and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

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

	test "it returns the error on registration problems" do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear"
	}

	{:error, error_object} = TwitterAPI.register_user(data)

	assert is_binary(error_object[:error])
	refute Repo.get_by(User, nickname: "lain")
	end

	test "it assigns an integer conversation_id" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	status = ActivityRepresenter.to_map(note_activity, %{user: user})

	assert is_number(status["statusnet_conversation_id"])
	end

	setup do
	Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
	Supervisor.restart_child(Pleroma.Supervisor, Cachex)
	:ok
	end

	describe "context_to_conversation_id" do
	test "creates a mapping object" do
	conversation_id = TwitterAPI.context_to_conversation_id("random context")
	object = Object.get_by_ap_id("random context")

	assert conversation_id == object.id
	end

	test "returns an existing mapping for an existing object" do
	{:ok, object} = Object.context_mapping("random context") \|> Repo.insert
	conversation_id = TwitterAPI.context_to_conversation_id("random context")

	assert conversation_id == object.id
	end
	end

	describe "fetching a user by uri" do
	test "fetches a user by uri" do
	id = "https://mastodon.social/users/lambadalambda"
	user = insert(:user)
	{:ok, represented} = TwitterAPI.get_external_profile(user, id)
	remote = User.get_by_ap_id(id)

	assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]

	# Also fetches the feed.
	assert Activity.get_create_activity_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 4:07 AM (14 h, 30 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802408
Default Alt Text: (65 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions