No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index 4eac8a8fd..b3b505be2 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,388 +1,387 @@
	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}
	import Ecto.Query

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

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

	def fetch_friend_statuses(user, opts \\ %{}) do
	opts =
	opts
	\|> Map.put("blocking_user", user)
	\|> Map.put("user", user)
	\|> Map.put("type", ["Create", "Announce", "Follow", "Like"])

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

	def fetch_public_statuses(user, opts \\ %{}) do
	opts =
	opts
	\|> Map.put("local_only", true)
	\|> Map.put("blocking_user", user)
	\|> Map.put("type", ["Create", "Announce", "Follow"])

	ActivityPub.fetch_public_activities(opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_public_and_external_statuses(user, opts \\ %{}) do
	opts =
	opts
	\|> Map.put("blocking_user", user)
	\|> Map.put("type", ["Create", "Announce", "Follow"])

	ActivityPub.fetch_public_activities(opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_user_statuses(user, opts \\ %{}) do
	opts =
	opts
	\|> Map.put("type", ["Create"])

	ActivityPub.fetch_public_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,
	"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),
	true <- ActivityPub.visible_for_user?(activity, user) 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,
	# get latest Follow for these users
	"object" => follow_activity.data["id"],
	"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
	}
	\|> Jason.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)
	\|> Jason.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)

	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,
	# this one isn't indexed so psql won't take the wrong index.
	order_by: [desc: :inserted_at]
	)

	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.recipients \|\| [], 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 %User{} = user <- User.get_or_fetch(uri) do
	spawn(fn ->
	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
	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 a8bcae5ba..fb09deada 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	@@ -1,363 +1,389 @@
	defmodule Pleroma.Web.TwitterAPI.Controller do
	use Pleroma.Web, :controller
	alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView, ActivityView}
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	alias Pleroma.Web.CommonAPI
	alias Pleroma.{Repo, Activity, User}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Ecto.Changeset

	require Logger

	def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
	token = Phoenix.Token.sign(conn, "user socket", user.id)
	render(conn, UserView, "show.json", %{user: user, token: token})
	end

	def status_update(%{assigns: %{user: user}} = conn, %{"status" => _} = 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}))
	+ \|> json(ActivityView.render("activity.json", activity: activity, for: 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} = Jason.encode(statuses)
	+ params =
	+ params
	+ \|> Map.put("type", ["Create", "Announce", "Follow"])
	+ \|> Map.put("blocking_user", user)
	+
	+ activities = ActivityPub.fetch_public_activities(params)

	conn
	- \|> json_reply(200, json)
	+ \|> render(ActivityView, "index.json", %{activities: activities, for: user})
	end

	def public_timeline(%{assigns: %{user: user}} = conn, params) do
	- statuses = TwitterAPI.fetch_public_statuses(user, params)
	- {:ok, json} = Jason.encode(statuses)
	+ params =
	+ params
	+ \|> Map.put("type", ["Create", "Announce", "Follow"])
	+ \|> Map.put("local_only", true)
	+ \|> Map.put("blocking_user", user)
	+
	+ activities = ActivityPub.fetch_public_activities(params)

	conn
	- \|> json_reply(200, json)
	+ \|> render(ActivityView, "index.json", %{activities: activities, for: user})
	end

	def friends_timeline(%{assigns: %{user: user}} = conn, params) do
	- statuses = TwitterAPI.fetch_friend_statuses(user, params)
	- {:ok, json} = Jason.encode(statuses)
	+ params =
	+ params
	+ \|> Map.put("type", ["Create", "Announce", "Follow", "Like"])
	+ \|> Map.put("blocking_user", user)
	+ \|> Map.put("user", user)
	+
	+ activities = ActivityPub.fetch_activities([user.ap_id \| user.following], params)

	conn
	- \|> json_reply(200, json)
	+ \|> render(ActivityView, "index.json", %{activities: activities, for: user})
	end

	def show_user(conn, params) do
	with {:ok, shown} <- TwitterAPI.get_user(params) do
	if user = conn.assigns.user do
	render(conn, UserView, "show.json", %{user: shown, for: user})
	else
	render(conn, UserView, "show.json", %{user: shown})
	end
	else
	{:error, msg} ->
	bad_request_reply(conn, msg)
	end
	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, "whole_db" => true})
	- statuses = TwitterAPI.fetch_user_statuses(user, params)
	+ params =
	+ params
	+ \|> Map.put("type", ["Create", "Announce"])
	+ \|> Map.put("actor_id", target_user.ap_id)
	+ \|> Map.put("whole_db", true)
	+
	+ activities = ActivityPub.fetch_public_activities(params)

	conn
	- \|> json_reply(200, statuses \|> Jason.encode!())
	+ \|> render(ActivityView, "index.json", %{activities: activities, for: user})

	{: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} = Jason.encode(statuses)
	+ activities = ActivityPub.fetch_activities([user.ap_id], params)

	conn
	- \|> json_reply(200, json)
	+ \|> render(ActivityView, "index.json", %{activities: activities, for: user})
	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
	with %Activity{} = activity <- Repo.get(Activity, id),
	true <- ActivityPub.visible_for_user?(activity, user) do
	render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
	end
	end

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

	- conn
	- \|> json_reply(200, response)
	+ with context when is_binary(context) <- TwitterAPI.conversation_id_to_context(id),
	+ activities <-
	+ ActivityPub.fetch_activities_for_context(context, %{
	+ "blocking_user" => user,
	+ "user" => user
	+ }) do
	+ conn
	+ \|> render(ActivityView, "index.json", %{activities: activities, for: user})
	+ end
	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, Jason.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} = User.update_and_set_cache(change)
	CommonAPI.update(user)

	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} <- User.update_and_set_cache(change) do
	CommonAPI.update(user)
	%{"url" => [%{"href" => href} \| _]} = object.data
	response = %{url: href} \|> Jason.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} <- User.update_and_set_cache(change) do
	%{"url" => [%{"href" => href} \| _]} = object.data
	response = %{url: href} \|> Jason.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 <- Jason.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} <- User.update_and_set_cache(changeset) do
	conn
	\|> json_reply(200, Jason.encode!(mrn))
	else
	_e -> bad_request_reply(conn, "Can't update.")
	end
	end

	def followers(conn, params) do
	with {:ok, user} <- TwitterAPI.get_user(conn.assigns.user, params),
	{: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(conn, params) do
	with {:ok, user} <- TwitterAPI.get_user(conn.assigns.user, params),
	{: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 friends_ids(%{assigns: %{user: user}} = conn, _params) do
	with {:ok, friends} <- User.get_friends(user) do
	ids =
	friends
	\|> Enum.map(fn x -> x.id end)
	\|> Jason.encode!()

	json(conn, ids)
	else
	_e -> bad_request_reply(conn, "Can't get friends")
	end
	end

	def empty_array(conn, _params) do
	json(conn, Jason.encode!([]))
	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} <- User.update_and_set_cache(changeset) do
	CommonAPI.update(user)
	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
	+ activities = TwitterAPI.search(user, params)
	+
	conn
	- \|> json(TwitterAPI.search(user, params))
	+ \|> render(ActivityView, "index.json", %{activities: activities, for: user})
	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} \|> Jason.encode!()
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/views/activity_view.ex b/lib/pleroma/web/twitter_api/views/activity_view.ex
	index 7c2501e16..3e69af3e3 100644
	--- a/lib/pleroma/web/twitter_api/views/activity_view.ex
	+++ b/lib/pleroma/web/twitter_api/views/activity_view.ex
	@@ -1,175 +1,185 @@
	defmodule Pleroma.Web.TwitterAPI.ActivityView do
	use Pleroma.Web, :view
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.User
	alias Pleroma.Web.TwitterAPI.UserView
	+ alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
	alias Pleroma.Activity
	alias Pleroma.Formatter

	+ def render("index.json", opts) do
	+ render_many(
	+ opts.activities,
	+ ActivityView,
	+ "activity.json",
	+ opts
	+ )
	+ end
	+
	def render("activity.json", %{activity: %{data: %{"type" => "Delete"}} = activity} = opts) do
	user = User.get_cached_by_ap_id(activity.data["actor"])
	created_at = activity.data["published"] \|> Utils.date_to_asctime()

	%{
	"id" => activity.id,
	"uri" => activity.data["object"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => "deleted notice {{tag",
	"text" => "deleted notice {{tag",
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "delete"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Follow"}} = activity} = opts) do
	user = User.get_cached_by_ap_id(activity.data["actor"])
	created_at = activity.data["published"] \|\| DateTime.to_iso8601(activity.inserted_at)
	created_at = created_at \|> Utils.date_to_asctime()

	followed = User.get_cached_by_ap_id(activity.data["object"])
	text = "#{user.nickname} started following #{followed.nickname}"

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "follow"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Announce"}} = activity} = opts) do
	user = User.get_by_ap_id(activity.data["actor"])
	created_at = activity.data["published"] \|> Utils.date_to_asctime()
	announced_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])

	text = "#{user.nickname} retweeted a status."

	retweeted_status = render("activity.json", Map.merge(opts, %{activity: announced_activity}))

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=note",
	"created_at" => created_at,
	"retweeted_status" => retweeted_status,
	"statusnet_conversation_id" => conversation_id(announced_activity),
	"external_url" => activity.data["id"],
	"activity_type" => "repeat"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Like"}} = activity} = opts) do
	user = User.get_cached_by_ap_id(activity.data["actor"])
	liked_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])

	created_at =
	activity.data["published"]
	\|> Utils.date_to_asctime()

	text = "#{user.nickname} favorited a status."

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=Favourite",
	"created_at" => created_at,
	"in_reply_to_status_id" => liked_activity.id,
	"external_url" => activity.data["id"],
	"activity_type" => "like"
	}
	end

	def render(
	"activity.json",
	%{activity: %{data: %{"type" => "Create", "object" => object}} = activity} = opts
	) do
	actor = get_in(activity.data, ["actor"])
	user = User.get_cached_by_ap_id(actor)

	created_at = object["published"] \|> Utils.date_to_asctime()
	like_count = object["like_count"] \|\| 0
	announcement_count = object["announcement_count"] \|\| 0
	favorited = opts[:for] && opts[:for].ap_id in (object["likes"] \|\| [])
	repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] \|\| [])

	attentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> UserView.render("show.json", %{user: user, for: opts[:for]}) end)

	conversation_id = conversation_id(activity)

	tags = activity.data["object"]["tag"] \|\| []
	possibly_sensitive = activity.data["object"]["sensitive"] \|\| Enum.member?(tags, "nsfw")

	tags = if possibly_sensitive, do: Enum.uniq(["nsfw" \| tags]), else: tags

	summary = activity.data["object"]["summary"]
	content = object["content"]

	content =
	if !!summary and summary != "" do
	"<span>#{activity.data["object"]["summary"]}</span><br />#{content}</span>"
	else
	content
	end

	html =
	HtmlSanitizeEx.basic_html(content)
	\|> Formatter.emojify(object["emoji"])

	%{
	"id" => activity.id,
	"uri" => activity.data["object"]["id"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => html,
	"text" => HtmlSanitizeEx.strip_tags(content),
	"is_local" => activity.local,
	"is_post_verb" => true,
	"created_at" => created_at,
	"in_reply_to_status_id" => object["inReplyToStatusId"],
	"statusnet_conversation_id" => conversation_id,
	"attachments" => (object["attachment"] \|\| []) \|> ObjectRepresenter.enum_to_list(opts),
	"attentions" => attentions,
	"fave_num" => like_count,
	"repeat_num" => announcement_count,
	"favorited" => !!favorited,
	"repeated" => !!repeated,
	"external_url" => object["external_url"] \|\| object["id"],
	"tags" => tags,
	"activity_type" => "post",
	"possibly_sensitive" => possibly_sensitive
	}
	end

	defp conversation_id(activity) do
	with context when not is_nil(context) <- activity.data["context"] do
	TwitterAPI.context_to_conversation_id(context)
	else
	_e -> nil
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 12:14 PM (1 d, 23 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1767243
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions