No OneTemporary
Actions

Size

41 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 4eab2e2d0..0fb8db520 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,207 +1,213 @@
	defmodule Pleroma.Web.ActivityPub.ActivityPub do
	alias Pleroma.Repo
	alias Pleroma.{Activity, Object, Upload, User}
	import Ecto.Query

	def insert(map, local \\ true) when is_map(map) do
	map = map
	\|> Map.put_new_lazy("id", &generate_activity_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)

	map = if is_map(map["object"]) do
	object = Map.put_new_lazy(map["object"], "id", &generate_object_id/0)
	Repo.insert!(%Object{data: object})
	Map.put(map, "object", object)
	else
	map
	end

	Repo.insert(%Activity{data: map, local: local})
	end

	def create(to, actor, context, object, additional \\ %{}, published \\ nil, local \\ true) do
	published = published \|\| make_date()

	activity = %{
	"type" => "Create",
	"to" => to,
	"actor" => actor.ap_id,
	"object" => object,
	"published" => published,
	"context" => context
	}
	\|> Map.merge(additional)

	with {:ok, activity} <- insert(activity, local) do
	if actor.local do
	Pleroma.Web.Federator.enqueue(:publish, activity)
	end

	{:ok, activity}
	end
	end

	def like(%User{ap_id: ap_id} = user, %Object{data: %{ "id" => id}} = object) do
	cond do
	# There's already a like here, so return the original activity.
	ap_id in (object.data["likes"] \|\| []) ->
	query = from activity in Activity,
	where: fragment("? @> ?", activity.data, ^%{actor: ap_id, object: id, type: "Like"})

	activity = Repo.one(query)
	{:ok, activity, object}
	true ->
	data = %{
	"type" => "Like",
	"actor" => ap_id,
	"object" => id,
	"to" => [User.ap_followers(user), object.data["actor"]]
	}

	{:ok, activity} = insert(data)

	likes = [ap_id \| (object.data["likes"] \|\| [])] \|> Enum.uniq

	new_data = object.data
	\|> Map.put("like_count", length(likes))
	\|> Map.put("likes", likes)

	changeset = Ecto.Changeset.change(object, data: new_data)
	{:ok, object} = Repo.update(changeset)

	update_object_in_activities(object)

	{:ok, activity, object}
	end
	end

	defp update_object_in_activities(%{data: %{"id" => id}} = object) do
	# Update activities that already had this. Could be done in a seperate process.
	relevant_activities = Activity.all_by_object_ap_id(id)
	Enum.map(relevant_activities, fn (activity) ->
	new_activity_data = activity.data \|> Map.put("object", object.data)
	changeset = Ecto.Changeset.change(activity, data: new_activity_data)
	Repo.update(changeset)
	end)
	end

	def unlike(%User{ap_id: ap_id}, %Object{data: %{ "id" => id}} = object) do
	query = from activity in Activity,
	where: fragment("? @> ?", activity.data, ^%{actor: ap_id, object: id, type: "Like"})

	activity = Repo.one(query)

	if activity do
	# just delete for now...
	{:ok, _activity} = Repo.delete(activity)

	likes = (object.data["likes"] \|\| []) \|> List.delete(ap_id)

	new_data = object.data
	\|> Map.put("like_count", length(likes))
	\|> Map.put("likes", likes)

	changeset = Ecto.Changeset.change(object, data: new_data)
	{:ok, object} = Repo.update(changeset)

	update_object_in_activities(object)

	{:ok, object}
	else
	{:ok, object}
	end
	end

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	generate_id("objects")
	end

	def generate_id(type) do
	"#{Pleroma.Web.base_url()}/#{type}/#{Ecto.UUID.generate}"
	end

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

	def fetch_activities(recipients, opts \\ %{}) do
	since_id = opts["since_id"] \|\| 0

	query = from activity in Activity,
	limit: 20,
	order_by: [desc: :inserted_at]

	query = Enum.reduce(recipients, query, fn (recipient, q) ->
	map = %{ to: [recipient] }
	from activity in q,
	or_where: fragment(~s(? @> ?), activity.data, ^map)
	end)

	query = from activity in query,
	where: activity.id > ^since_id

	+ query = if opts["local_only"] do
	+ from activity in query, where: activity.local == true
	+ else
	+ query
	+ end
	+
	query = if opts["max_id"] do
	from activity in query, where: activity.id < ^opts["max_id"]
	else
	query
	end

	query = if opts["actor_id"] do
	from activity in query,
	where: fragment("? @> ?", activity.data, ^%{actor: opts["actor_id"]})
	else
	query
	end

	Repo.all(query)
	\|> Enum.reverse
	end

	def announce(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object) do
	data = %{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [User.ap_followers(user), object.data["actor"]]
	}

	{:ok, activity} = insert(data)

	announcements = [ap_id \| (object.data["announcements"] \|\| [])] \|> Enum.uniq

	new_data = object.data
	\|> Map.put("announcement_count", length(announcements))
	\|> Map.put("announcements", announcements)

	changeset = Ecto.Changeset.change(object, data: new_data)
	{:ok, object} = Repo.update(changeset)

	update_object_in_activities(object)

	{:ok, activity, object}
	end

	def fetch_activities_for_context(context) do
	query = from activity in Activity,
	where: fragment("? @> ?", activity.data, ^%{ context: context })
	Repo.all(query)
	end

	def upload(file) do
	data = Upload.store(file)
	Repo.insert(%Object{data: data})
	end

	defp make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index e1475a03e..b0c1dcd91 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,100 +1,100 @@
	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router

	alias Pleroma.{Repo, User}

	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.AuthenticationPlug, %{fetcher: &Pleroma.Web.Router.user_fetcher/1, optional: true}
	end

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

	pipeline :well_known do
	plug :accepts, ["xml", "xrd+xml"]
	end

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

	get "/help/test", TwitterAPI.Controller, :help_test
	get "/statusnet/config", TwitterAPI.Controller, :config

	get "/statuses/public_timeline", TwitterAPI.Controller, :public_timeline
	- get "/statuses/public_and_external_timeline", TwitterAPI.Controller, :public_timeline
	+ get "/statuses/public_and_external_timeline", TwitterAPI.Controller, :public_and_external_timeline
	get "/statuses/user_timeline", TwitterAPI.Controller, :user_timeline

	get "/statuses/show/:id", TwitterAPI.Controller, :fetch_status
	get "/statusnet/conversation/:id", TwitterAPI.Controller, :fetch_conversation

	post "/account/register", TwitterAPI.Controller, :register
	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

	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 "/friendships/create", TwitterAPI.Controller, :follow
	post "/friendships/destroy", TwitterAPI.Controller, :unfollow

	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
	end

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

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

	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: send_file(conn, 200, "priv/static/index.html")
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index e6f5fc906..b1759a6f0 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,335 +1,341 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
	alias Pleroma.{User, Activity, Repo, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.Representers.{ActivityRepresenter, UserRepresenter}

	import Ecto.Query

	def to_for_user_and_mentions(user, mentions) do
	default_to = [
	User.ap_followers(user),
	"https://www.w3.org/ns/activitystreams#Public"
	]

	default_to ++ Enum.map(mentions, fn ({_, %{ap_id: ap_id}}) -> ap_id end)
	end

	def format_input(text, mentions) do
	HtmlSanitizeEx.strip_tags(text)
	\|> String.replace("\n", "<br>")
	\|> add_user_links(mentions)
	end

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

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

	def get_replied_to_activity(_), do: nil

	def create_status(user = %User{}, data = %{"status" => status}) do
	attachments = attachments_from_ids(data["media_ids"])
	context = ActivityPub.generate_context_id
	mentions = parse_mentions(status)
	content_html = format_input(status, mentions)
	to = to_for_user_and_mentions(user, mentions)
	date = make_date()

	inReplyTo = get_replied_to_activity(data["in_reply_to_status_id"])

	# Wire up reply info.
	[to, context, object, additional] =
	if inReplyTo do
	context = inReplyTo.data["context"]
	to = to ++ [inReplyTo.data["actor"]]

	object = %{
	"type" => "Note",
	"to" => to,
	"content" => content_html,
	"published" => date,
	"context" => context,
	"attachment" => attachments,
	"actor" => user.ap_id,
	"inReplyTo" => inReplyTo.data["object"]["id"],
	"inReplyToStatusId" => inReplyTo.id,
	}
	additional = %{}

	[to, context, object, additional]
	else
	object = %{
	"type" => "Note",
	"to" => to,
	"content" => content_html,
	"published" => date,
	"context" => context,
	"attachment" => attachments,
	"actor" => user.ap_id
	}
	[to, context, object, %{}]
	end

	ActivityPub.create(to, user, context, object, additional, data)
	end

	def fetch_friend_statuses(user, opts \\ %{}) do
	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)
	+ ActivityPub.fetch_public_activities(opts)
	+ \|> activities_to_statuses(%{for: user})
	+ end
	+
	+ def fetch_public_and_external_statuses(user, opts \\ %{}) do
	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),
	statuses <- activities \|> activities_to_statuses(%{for: user})
	do
	statuses
	else e ->
	IO.inspect(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.insert(%{
	"type" => "Follow",
	"actor" => follower.ap_id,
	"object" => followed.ap_id,
	"published" => make_date()
	})
	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 } <- User.unfollow(follower, unfollowed)
	do
	{ :ok, follower, unfollowed}
	else
	err -> err
	end
	end

	def favorite(%User{} = user, %Activity{data: %{"object" => object}} = activity) do
	object = Object.get_by_ap_id(object["id"])

	{:ok, _like_activity, object} = ActivityPub.like(user, object)
	new_data = activity.data
	\|> Map.put("object", object.data)

	status = %{activity \| data: new_data}
	\|> activity_to_status(%{for: user})

	{:ok, status}
	end

	def unfavorite(%User{} = user, %Activity{data: %{"object" => object}} = activity) do
	object = Object.get_by_ap_id(object["id"])

	{:ok, object} = ActivityPub.unlike(user, object)
	new_data = activity.data
	\|> Map.put("object", object.data)

	status = %{activity \| data: new_data}
	\|> activity_to_status(%{for: user})

	{:ok, status}
	end

	def retweet(%User{} = user, %Activity{data: %{"object" => object}} = activity) do
	object = Object.get_by_ap_id(object["id"])

	{:ok, _announce_activity, object} = ActivityPub.announce(user, object)
	new_data = activity.data
	\|> Map.put("object", object.data)

	status = %{activity \| data: new_data}
	\|> activity_to_status(%{for: user})

	{:ok, status}
	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 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])?)/

	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 add_user_links(text, mentions) do
	Enum.reduce(mentions, text, fn ({match, %User{ap_id: ap_id}}, text) -> String.replace(text, match, "<a href='#{ap_id}'>#{match}</a>") 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, UserRepresenter.to_map(user)}
	else
	{:error, changeset} ->
	errors = Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
	\|> Poison.encode!
	{:error, %{error: errors}}
	end
	end

	def get_user(user \\ nil, params) do
	case params do
	%{ "user_id" => user_id } ->
	case target = Repo.get(User, 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 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, 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) ->
	User.get_cached_by_ap_id(ap_id)
	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)
	{:ok, %{id: id}} = Repo.insert(changeset)
	id
	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
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api_controller.ex b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	index b5b829ca0..4b329a21f 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	@@ -1,220 +1,228 @@
	defmodule Pleroma.Web.TwitterAPI.Controller do
	use Pleroma.Web, :controller
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.Representers.{UserRepresenter, ActivityRepresenter}
	alias Pleroma.{Repo, Activity}
	alias Pleroma.Web.ActivityPub.ActivityPub

	def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
	response = user \|> UserRepresenter.to_json(%{for: user})

	conn
	\|> json_reply(200, response)
	end

	def status_update(%{assigns: %{user: user}} = conn, %{"status" => status_text} = status_data) do
	if status_text \|> String.trim \|> String.length != 0 do
	media_ids = extract_media_ids(status_data)
	{:ok, activity} = TwitterAPI.create_status(user, Map.put(status_data, "media_ids", media_ids ))
	conn
	\|> json_reply(200, ActivityRepresenter.to_json(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 } ->
	response = followed \|> UserRepresenter.to_json(%{for: user})
	conn
	\|> json_reply(200, response)
	{ :error, msg } -> forbidden_json_reply(conn, msg)
	end
	end

	def unfollow(%{assigns: %{user: user}} = conn, params) do
	case TwitterAPI.unfollow(user, params) do
	{ :ok, user, unfollowed, } ->
	response = unfollowed \|> UserRepresenter.to_json(%{for: user})
	conn
	\|> json_reply(200, response)
	{ :error, msg } -> forbidden_json_reply(conn, msg)
	end
	end

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

	conn
	\|> json_reply(200, response)
	end

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

	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 help_test(conn, _params) do
	conn \|> json_reply(200, Poison.encode!("ok"))
	end

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

	def config(conn, _params) do
	response = %{
	site: %{
	name: Pleroma.Web.base_url,
	server: Pleroma.Web.base_url,
	textlimit: -1
	}
	}
	\|> Poison.encode!

	conn
	\|> json_reply(200, response)
	end

	def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	activity = Repo.get(Activity, id)
	{:ok, status} = TwitterAPI.favorite(user, activity)
	response = Poison.encode!(status)

	conn
	\|> json_reply(200, response)
	end

	def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	activity = Repo.get(Activity, id)
	{:ok, status} = TwitterAPI.unfavorite(user, activity)
	response = Poison.encode!(status)

	conn
	\|> json_reply(200, response)
	end

	def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	activity = Repo.get(Activity, id)
	if activity.data["actor"] == user.ap_id do
	bad_request_reply(conn, "You cannot repeat your own notice.")
	else
	{:ok, status} = TwitterAPI.retweet(user, activity)
	response = Poison.encode!(status)

	conn

	\|> json_reply(200, response)
	end
	end

	def register(conn, params) do
	with {:ok, user} <- TwitterAPI.register_user(params) do
	conn
	\|> json_reply(200, Poison.encode!(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 = Ecto.Changeset.change(user, %{avatar: object.data})
	{:ok, user} = Repo.update(change)

	response = UserRepresenter.to_map(user, %{for: user})
	\|> Poison.encode!

	conn
	\|> json_reply(200, response)
	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_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index 57dcddd4c..4e17f3298 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,345 +1,358 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	alias Pleroma.Builders.{UserBuilder, ActivityBuilder}
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.{Activity, User, Object, Repo}
	alias Pleroma.Web.TwitterAPI.Representers.{ActivityRepresenter, UserRepresenter}
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Pleroma.Factory

	test "create a status" do
	user = UserBuilder.build(%{ap_id: "142344"})
	_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.",
	"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>This is on another line."
	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

	# 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
	end

	test "create a status that is a reply" do
	user = UserBuilder.build(%{ap_id: "some_cool_id"})
	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"]), "some_cool_id")
	end

	- test "fetch public statuses" do
	+ 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, %{"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)]

	{ :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)]})

	{: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)]})

	{: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 "fetch statuses in a context using the conversation id" do
	{:ok, user} = UserBuilder.insert()
	{:ok, activity} = ActivityBuilder.insert(%{"context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"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, 0)["id"] == activity.id
	assert Enum.at(statuses, 1)["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 can parse mentions and return the relevant users" do
	text = "@gsimg According to @archaeme , that is @daggsy."

	gsimg = insert(:user, %{nickname: "gsimg"})
	archaeme = insert(:user, %{nickname: "archaeme"})

	expected_result = [
	{"@gsimg", gsimg},
	{"@archaeme", archaeme}
	]

	assert TwitterAPI.parse_mentions(text) == expected_result
	end

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

	gsimg = insert(:user, %{nickname: "gsimg"})
	archaeme = insert(:user, %{nickname: "archaeme"})

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

	assert TwitterAPI.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.favorite(user, note_activity)
	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.unfavorite(user, note_activity)

	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.retweet(user, note_activity)
	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 user == UserRepresenter.to_map(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
	end

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 14, 7:14 AM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 166677
Default Alt Text: (41 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions