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.TwitterAPI.{TwitterAPI, UserView, ActivityView, NotificationView}
alias Pleroma.Web.CommonAPI
- alias Pleroma.{Repo, Activity, User}
+ alias Pleroma.{Repo, Activity, User, Notification}
alias Pleroma.Web.ActivityPub.ActivityPub
alias Ecto.Changeset
require Logger
+ action_fallback(:errors)
+
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})
{: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 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"])
+ |> 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"])
+ |> 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
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)
+ activities = ActivityPub.fetch_user_activities(target_user, user, params)
conn
- |> json_reply(200, statuses |> Jason.encode!())
+ |> render(ActivityView, "index.json", %{activities: activities, for: user})
{:error, msg} ->
bad_request_reply(conn, msg)
end
def mentions_timeline(%{assigns: %{user: user}} = conn, params) do
- statuses = TwitterAPI.fetch_mentions(user, params)
- {:ok, json} = Jason.encode(statuses)
+ params =
+ params
+ |> Map.put("type", ["Create", "Announce", "Follow", "Like"])
+ |> Map.put("blocking_user", user)
+
+ activities = ActivityPub.fetch_activities([user.ap_id], params)
conn
- |> json_reply(200, json)
+ |> render(ActivityView, "index.json", %{activities: activities, for: user})
+ end
+
+ def notifications(%{assigns: %{user: user}} = conn, params) do
+ notifications = Notification.for_user(user, params)
+
+ conn
+ |> render(NotificationView, "notification.json", %{notifications: notifications, for: user})
end
def follow(%{assigns: %{user: user}} = conn, params) do
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)
+ with {:ok, activity} <- TwitterAPI.delete(user, id) 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
end
def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with {:ok, status} <- TwitterAPI.fav(user, id) do
- json(conn, status)
+ with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
+ {:ok, activity} <- TwitterAPI.fav(user, id) do
+ render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
end
end
def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with {:ok, status} <- TwitterAPI.unfav(user, id) do
- json(conn, status)
+ with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
+ {:ok, activity} <- TwitterAPI.unfav(user, id) do
+ render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
end
end
def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with {:ok, status} <- TwitterAPI.repeat(user, id) do
- json(conn, status)
+ with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
+ {:ok, activity} <- TwitterAPI.repeat(user, id) do
+ render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
end
end
end
def followers(conn, params) do
- with {:ok, user} <- TwitterAPI.get_user(conn.assigns.user, params),
+ 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})
+ render(conn, UserView, "index.json", %{users: followers, for: conn.assigns[: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),
+ 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})
+ render(conn, UserView, "index.json", %{users: friends, for: conn.assigns[:user]})
else
_e -> bad_request_reply(conn, "Can't get friends")
end
def update_profile(%{assigns: %{user: user}} = conn, params) do
params =
if bio = params["description"] do
- Map.put(params, "bio", bio)
+ bio_brs = Regex.replace(~r/\r?\n/, bio, "<br>")
+ Map.put(params, "bio", bio_brs)
else
params
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
defp error_json(conn, error_message) do
%{"error" => error_message, "request" => conn.request_path} |> Jason.encode!()
end
+
+ def errors(conn, {:param_cast, _}) do
+ conn
+ |> put_status(400)
+ |> json("Invalid parameters")
+ end
+
+ def errors(conn, _) do
+ conn
+ |> put_status(500)
+ |> json("Something went wrong")
+ end
end