+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
use Pleroma.Web, :controller
alias Pleroma.{Repo, Object, Activity, User, Notification, Stats}
end
def user(%{assigns: %{user: for_user}} = conn, %{"id" => id}) do
- with %User{} = user <- Repo.get(User, id) do
+ with %User{} = user <- Repo.get(User, id),
+ true <- User.auth_active?(user) || user.id == for_user.id || User.superuser?(for_user) do
account = AccountView.render("account.json", %{user: user, for: for_user})
json(conn, account)
else
conn
|> add_link_headers(:home_timeline, activities)
- |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
+ |> put_view(StatusView)
+ |> render("index.json", %{activities: activities, for: user, as: :activity})
end
def public_timeline(%{assigns: %{user: user}} = conn, params) do
conn
|> add_link_headers(:public_timeline, activities, false, %{"local" => local_only})
- |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
+ |> put_view(StatusView)
+ |> render("index.json", %{activities: activities, for: user, as: :activity})
end
def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
with %User{} = user <- Repo.get(User, params["id"]) do
- # Since Pleroma has no "pinned" posts feature, we'll just set an empty list here
- activities =
- if params["pinned"] == "true" do
- []
- else
- ActivityPub.fetch_user_activities(user, reading_user, params)
- end
+ activities = ActivityPub.fetch_user_activities(user, reading_user, params)
conn
|> add_link_headers(:user_statuses, activities, params["id"])
- |> render(StatusView, "index.json", %{
+ |> put_view(StatusView)
+ |> render("index.json", %{
activities: activities,
for: reading_user,
as: :activity
conn
|> add_link_headers(:dm_timeline, activities)
- |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
+ |> put_view(StatusView)
+ |> render("index.json", %{activities: activities, for: user, as: :activity})
end
def get_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
with %Activity{} = activity <- Repo.get(Activity, id),
true <- ActivityPub.visible_for_user?(activity, user) do
- try_render(conn, StatusView, "status.json", %{activity: activity, for: user})
+ conn
+ |> put_view(StatusView)
+ |> try_render("status.json", %{activity: activity, for: user})
end
end
params =
params
|> Map.put("in_reply_to_status_id", params["in_reply_to_id"])
- |> Map.put("no_attachment_links", true)
idempotency_key =
case get_req_header(conn, "idempotency-key") do
{:ok, activity} =
Cachex.fetch!(:idempotency_cache, idempotency_key, fn _ -> CommonAPI.post(user, params) end)
- try_render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
+ conn
+ |> put_view(StatusView)
+ |> try_render("status.json", %{activity: activity, for: user, as: :activity})
end
def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user) do
- try_render(conn, StatusView, "status.json", %{activity: announce, for: user, as: :activity})
+ conn
+ |> put_view(StatusView)
+ |> try_render("status.json", %{activity: announce, for: user, as: :activity})
end
end
def unreblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
- %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
- try_render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
+ %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
+ conn
+ |> put_view(StatusView)
+ |> try_render("status.json", %{activity: activity, for: user, as: :activity})
end
end
def fav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
- %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
- try_render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
+ %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
+ conn
+ |> put_view(StatusView)
+ |> try_render("status.json", %{activity: activity, for: user, as: :activity})
end
end
def unfav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
- %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
- try_render(conn, StatusView, "status.json", %{activity: activity, for: user, as: :activity})
+ %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
+ conn
+ |> put_view(StatusView)
+ |> try_render("status.json", %{activity: activity, for: user, as: :activity})
+ end
+ end
+
+ def pin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
+ with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
+ conn
+ |> put_view(StatusView)
+ |> try_render("status.json", %{activity: activity, for: user, as: :activity})
+ else
+ {:error, reason} ->
+ conn
+ |> put_resp_content_type("application/json")
+ |> send_resp(:bad_request, Jason.encode!(%{"error" => reason}))
+ end
+ end
+
+ def unpin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
+ with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
+ conn
+ |> put_view(StatusView)
+ |> try_render("status.json", %{activity: activity, for: user, as: :activity})
+ end
+ end
+
+ def bookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+ with %Activity{} = activity <- Repo.get(Activity, id),
+ %User{} = user <- User.get_by_nickname(user.nickname),
+ true <- ActivityPub.visible_for_user?(activity, user),
+ {:ok, user} <- User.bookmark(user, activity.data["object"]["id"]) do
+ conn
+ |> put_view(StatusView)
+ |> try_render("status.json", %{activity: activity, for: user, as: :activity})
+ end
+ end
+
+ def unbookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+ with %Activity{} = activity <- Repo.get(Activity, id),
+ %User{} = user <- User.get_by_nickname(user.nickname),
+ true <- ActivityPub.visible_for_user?(activity, user),
+ {:ok, user} <- User.unbookmark(user, activity.data["object"]["id"]) do
+ conn
+ |> put_view(StatusView)
+ |> try_render("status.json", %{activity: activity, for: user, as: :activity})
end
end
id = List.wrap(id)
q = from(u in User, where: u.id in ^id)
targets = Repo.all(q)
- render(conn, AccountView, "relationships.json", %{user: user, targets: targets})
+
+ conn
+ |> put_view(AccountView)
+ |> render("relationships.json", %{user: user, targets: targets})
end
# Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array.
|> Repo.update()
attachment_data = Map.put(new_data, "id", object.id)
- render(conn, StatusView, "attachment.json", %{attachment: attachment_data})
+
+ conn
+ |> put_view(StatusView)
+ |> render("attachment.json", %{attachment: attachment_data})
end
end
def upload(%{assigns: %{user: user}} = conn, %{"file" => file} = data) do
with {:ok, object} <-
- ActivityPub.upload(file,
+ ActivityPub.upload(
+ file,
actor: User.ap_id(user),
description: Map.get(data, "description")
) do
attachment_data = Map.put(object.data, "id", object.id)
- render(conn, StatusView, "attachment.json", %{attachment: attachment_data})
+
+ conn
+ |> put_view(StatusView)
+ |> render("attachment.json", %{attachment: attachment_data})
end
end
with %Activity{data: %{"object" => %{"likes" => likes}}} <- Repo.get(Activity, id) do
q = from(u in User, where: u.ap_id in ^likes)
users = Repo.all(q)
- render(conn, AccountView, "accounts.json", %{users: users, as: :user})
+
+ conn
+ |> put_view(AccountView)
+ |> render(AccountView, "accounts.json", %{users: users, as: :user})
else
_ -> json(conn, [])
end
with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Repo.get(Activity, id) do
q = from(u in User, where: u.ap_id in ^announces)
users = Repo.all(q)
- render(conn, AccountView, "accounts.json", %{users: users, as: :user})
+
+ conn
+ |> put_view(AccountView)
+ |> render("accounts.json", %{users: users, as: :user})
else
_ -> json(conn, [])
end
def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
local_only = params["local"] in [true, "True", "true", "1"]
- params =
+ tags =
+ [params["tag"], params["any"]]
+ |> List.flatten()
+ |> Enum.uniq()
+ |> Enum.filter(& &1)
+ |> Enum.map(&String.downcase(&1))
+
+ tag_all =
+ params["all"] ||
+ []
+ |> Enum.map(&String.downcase(&1))
+
+ tag_reject =
+ params["none"] ||
+ []
+ |> Enum.map(&String.downcase(&1))
+
+ query_params =
params
|> Map.put("type", "Create")
|> Map.put("local_only", local_only)
|> Map.put("blocking_user", user)
- |> Map.put("tag", String.downcase(params["tag"]))
+ |> Map.put("tag", tags)
+ |> Map.put("tag_all", tag_all)
+ |> Map.put("tag_reject", tag_reject)
activities =
- ActivityPub.fetch_public_activities(params)
+ ActivityPub.fetch_public_activities(query_params)
|> Enum.reverse()
conn
|> add_link_headers(:hashtag_timeline, activities, params["tag"], %{"local" => local_only})
- |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
+ |> put_view(StatusView)
+ |> render("index.json", %{activities: activities, for: user, as: :activity})
end
def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id}) do
true -> followers
end
- render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
+ conn
+ |> put_view(AccountView)
+ |> render("accounts.json", %{users: followers, as: :user})
end
end
true -> followers
end
- render(conn, AccountView, "accounts.json", %{users: followers, as: :user})
+ conn
+ |> put_view(AccountView)
+ |> render("accounts.json", %{users: followers, as: :user})
end
end
def follow_requests(%{assigns: %{user: followed}} = conn, _params) do
with {:ok, follow_requests} <- User.get_follow_requests(followed) do
- render(conn, AccountView, "accounts.json", %{users: follow_requests, as: :user})
+ conn
+ |> put_view(AccountView)
+ |> render("accounts.json", %{users: follow_requests, as: :user})
end
end
object: follow_activity.data["id"],
type: "Accept"
}) do
- render(conn, AccountView, "relationship.json", %{user: followed, target: follower})
+ conn
+ |> put_view(AccountView)
+ |> render("relationship.json", %{user: followed, target: follower})
else
{:error, message} ->
conn
object: follow_activity.data["id"],
type: "Reject"
}) do
- render(conn, AccountView, "relationship.json", %{user: followed, target: follower})
+ conn
+ |> put_view(AccountView)
+ |> render("relationship.json", %{user: followed, target: follower})
else
{:error, message} ->
conn
follower,
followed
) do
- render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
+ conn
+ |> put_view(AccountView)
+ |> render("relationship.json", %{user: follower, target: followed})
else
{:error, message} ->
conn
with %User{} = followed <- Repo.get_by(User, nickname: uri),
{:ok, follower} <- User.maybe_direct_follow(follower, followed),
{:ok, _activity} <- ActivityPub.follow(follower, followed) do
- render(conn, AccountView, "account.json", %{user: followed, for: follower})
+ conn
+ |> put_view(AccountView)
+ |> render("account.json", %{user: followed, for: follower})
else
{:error, message} ->
conn
with %User{} = followed <- Repo.get(User, id),
{:ok, _activity} <- ActivityPub.unfollow(follower, followed),
{:ok, follower, _} <- User.unfollow(follower, followed) do
- render(conn, AccountView, "relationship.json", %{user: follower, target: followed})
+ conn
+ |> put_view(AccountView)
+ |> render("relationship.json", %{user: follower, target: followed})
end
end
with %User{} = blocked <- Repo.get(User, id),
{:ok, blocker} <- User.block(blocker, blocked),
{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
- render(conn, AccountView, "relationship.json", %{user: blocker, target: blocked})
+ conn
+ |> put_view(AccountView)
+ |> render("relationship.json", %{user: blocker, target: blocked})
else
{:error, message} ->
conn
with %User{} = blocked <- Repo.get(User, id),
{:ok, blocker} <- User.unblock(blocker, blocked),
{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
- render(conn, AccountView, "relationship.json", %{user: blocker, target: blocked})
+ conn
+ |> put_view(AccountView)
+ |> render("relationship.json", %{user: blocker, target: blocked})
else
{:error, message} ->
conn
end
end
- # TODO: Use proper query
def blocks(%{assigns: %{user: user}} = conn, _) do
- with blocked_users <- user.info.blocks || [],
- accounts <- Enum.map(blocked_users, fn ap_id -> User.get_cached_by_ap_id(ap_id) end) do
- res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
+ with blocked_accounts <- User.blocked_users(user) do
+ res = AccountView.render("accounts.json", users: blocked_accounts, for: user, as: :user)
json(conn, res)
end
end
json(conn, %{})
end
- def status_search(query) do
+ def status_search(user, query) do
fetched =
if Regex.match?(~r/https?:/, query) do
- with {:ok, object} <- ActivityPub.fetch_object_from_id(query) do
- [Activity.get_create_activity_by_object_ap_id(object.data["id"])]
+ with {:ok, object} <- ActivityPub.fetch_object_from_id(query),
+ %Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
+ true <- ActivityPub.visible_for_user?(activity, user) do
+ [activity]
else
_e -> []
end
end
def search2(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
- accounts = User.search(query, params["resolve"] == "true")
+ accounts = User.search(query, params["resolve"] == "true", user)
- statuses = status_search(query)
+ statuses = status_search(user, query)
tags_path = Web.base_url() <> "/tag/"
end
def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
- accounts = User.search(query, params["resolve"] == "true")
+ accounts = User.search(query, params["resolve"] == "true", user)
- statuses = status_search(query)
+ statuses = status_search(user, query)
tags =
String.split(query)
end
def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
- accounts = User.search(query, params["resolve"] == "true")
+ accounts = User.search(query, params["resolve"] == "true", user)
res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)
json(conn, res)
end
- def favourites(%{assigns: %{user: user}} = conn, _) do
+ def favourites(%{assigns: %{user: user}} = conn, params) do
params =
- %{}
+ params
|> Map.put("type", "Create")
|> Map.put("favorited_by", user.ap_id)
|> Map.put("blocking_user", user)
|> Enum.reverse()
conn
- |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
+ |> add_link_headers(:favourites, activities)
+ |> put_view(StatusView)
+ |> render("index.json", %{activities: activities, for: user, as: :activity})
+ end
+
+ def bookmarks(%{assigns: %{user: user}} = conn, _) do
+ user = Repo.get(User, user.id)
+
+ activities =
+ user.bookmarks
+ |> Enum.map(fn id -> Activity.get_create_by_object_ap_id(id) end)
+ |> Enum.reverse()
+
+ conn
+ |> put_view(StatusView)
+ |> render("index.json", %{activities: activities, for: user, as: :activity})
end
def get_lists(%{assigns: %{user: user}} = conn, opts) do
def list_accounts(%{assigns: %{user: user}} = conn, %{"id" => id}) do
with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
{:ok, users} = Pleroma.List.get_following(list) do
- render(conn, AccountView, "accounts.json", %{users: users, as: :user})
+ conn
+ |> put_view(AccountView)
+ |> render("accounts.json", %{users: users, as: :user})
end
end
|> Enum.reverse()
conn
- |> render(StatusView, "index.json", %{activities: activities, for: user, as: :activity})
+ |> put_view(StatusView)
+ |> render("index.json", %{activities: activities, for: user, as: :activity})
else
_e ->
conn
max_toot_chars: limit
},
rights: %{
- delete_others_notice: !!user.info.is_moderator
+ delete_others_notice: !!user.info.is_moderator,
+ admin: !!user.info.is_admin
},
compose: %{
me: "#{user.id}",
conn
|> put_layout(false)
- |> render(MastodonView, "index.html", %{initial_state: initial_state})
+ |> put_view(MastodonView)
+ |> render("index.html", %{initial_state: initial_state})
else
conn
|> redirect(to: "/web/login")
def login(conn, _) do
with {:ok, app} <- get_or_make_app() do
path =
- o_auth_path(conn, :authorize,
+ o_auth_path(
+ conn,
+ :authorize,
response_type: "code",
client_id: app.client_id,
redirect_uri: ".",
Logger.debug("Unimplemented, returning unmodified relationship")
with %User{} = target <- Repo.get(User, id) do
- render(conn, AccountView, "relationship.json", %{user: user, target: target})
+ conn
+ |> put_view(AccountView)
+ |> render("relationship.json", %{user: user, target: target})
end
end
def render_notification(user, %{id: id, activity: activity, inserted_at: created_at} = _params) do
actor = User.get_cached_by_ap_id(activity.data["actor"])
- parent_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
+ parent_activity = Activity.get_create_by_object_ap_id(activity.data["object"])
mastodon_type = Activity.mastodon_notification_type(activity)
response = %{
[],
adapter: [
timeout: timeout,
- recv_timeout: timeout
+ recv_timeout: timeout,
+ pool: :default
]
),
{:ok, data} <- Jason.decode(body) do
end
end
- def try_render(conn, renderer, target, params)
+ def status_card(conn, %{"id" => status_id}) do
+ with %Activity{} = activity <- Repo.get(Activity, status_id),
+ true <- ActivityPub.is_public?(activity) do
+ data =
+ StatusView.render(
+ "card.json",
+ Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
+ )
+
+ json(conn, data)
+ else
+ _e ->
+ %{}
+ end
+ end
+
+ def try_render(conn, target, params)
when is_binary(target) do
- res = render(conn, renderer, target, params)
+ res = render(conn, target, params)
if res == nil do
conn
end
end
- def try_render(conn, _, _, _) do
+ def try_render(conn, _, _) do
conn
|> put_status(501)
|> json(%{error: "Can't display this activity"})
projects / akkoma / blobdiff