Pleroma/lib/pleroma/web/mastodon_api/controllers/mastodon_api_controller.ex

383 lines
11 KiB
Elixir
Raw Normal View History

# Pleroma: A lightweight social networking server
2018-12-31 16:41:47 +01:00
# 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
import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2]
2019-04-14 14:45:56 +02:00
alias Pleroma.Bookmark
2019-02-09 16:16:26 +01:00
alias Pleroma.Config
alias Pleroma.Pagination
alias Pleroma.Plugs.RateLimiter
2019-02-09 16:16:26 +01:00
alias Pleroma.Repo
alias Pleroma.Stats
alias Pleroma.User
2017-09-07 08:58:10 +02:00
alias Pleroma.Web
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.CommonAPI
2019-02-09 16:16:26 +01:00
alias Pleroma.Web.MastodonAPI.AccountView
alias Pleroma.Web.MastodonAPI.AppView
2019-02-09 16:16:26 +01:00
alias Pleroma.Web.MastodonAPI.MastodonView
alias Pleroma.Web.MastodonAPI.StatusView
2019-02-09 16:16:26 +01:00
alias Pleroma.Web.OAuth.App
alias Pleroma.Web.OAuth.Authorization
alias Pleroma.Web.OAuth.Scopes
2019-02-09 16:16:26 +01:00
alias Pleroma.Web.OAuth.Token
alias Pleroma.Web.TwitterAPI.TwitterAPI
2018-12-06 14:50:20 +01:00
2017-11-19 02:22:07 +01:00
require Logger
plug(RateLimiter, :password_reset when action == :password_reset)
2019-06-11 09:28:39 +02:00
@local_mastodon_name "Mastodon-Local"
action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
def create_app(conn, params) do
scopes = Scopes.fetch_scopes(params, ["read"])
app_attrs =
params
|> Map.drop(["scope", "scopes"])
|> Map.put("scopes", scopes)
with cs <- App.register_changeset(%App{}, app_attrs),
false <- cs.changes[:client_name] == @local_mastodon_name,
{:ok, app} <- Repo.insert(cs) do
conn
|> put_view(AppView)
|> render("show.json", %{app: app})
end
end
def verify_app_credentials(%{assigns: %{user: _user, token: token}} = conn, _) do
with %Token{app: %App{} = app} <- Repo.preload(token, :app) do
conn
|> put_view(AppView)
|> render("short.json", %{app: app})
end
end
2019-05-13 22:52:16 +02:00
@mastodon_api_level "2.7.2"
2017-09-15 10:26:28 +02:00
2017-09-07 08:58:10 +02:00
def masto_instance(conn, _params) do
2019-02-03 18:44:18 +01:00
instance = Config.get(:instance)
2017-09-07 08:58:10 +02:00
response = %{
2018-03-30 15:01:53 +02:00
uri: Web.base_url(),
title: Keyword.get(instance, :name),
description: Keyword.get(instance, :description),
2018-11-20 17:55:03 +01:00
version: "#{@mastodon_api_level} (compatible; #{Pleroma.Application.named_version()})",
email: Keyword.get(instance, :email),
2017-09-15 10:26:28 +02:00
urls: %{
streaming_api: Pleroma.Web.Endpoint.websocket_url()
2017-09-15 10:26:28 +02:00
},
2018-03-30 15:01:53 +02:00
stats: Stats.get_stats(),
thumbnail: Web.base_url() <> "/instance/thumbnail.jpeg",
languages: ["en"],
registrations: Pleroma.Config.get([:instance, :registrations_open]),
# Extra (not present in Mastodon):
max_toot_chars: Keyword.get(instance, :limit),
poll_limits: Keyword.get(instance, :poll_limits)
}
2017-09-07 08:58:10 +02:00
json(conn, response)
end
2017-09-09 13:15:01 +02:00
def peers(conn, _params) do
2018-03-30 15:01:53 +02:00
json(conn, Stats.get_peers())
end
defp mastodonized_emoji do
Pleroma.Emoji.get_all()
2019-08-31 09:14:53 +02:00
|> Enum.map(fn {shortcode, %Pleroma.Emoji{file: relative_url, tags: tags}} ->
2018-03-30 15:01:53 +02:00
url = to_string(URI.merge(Web.base_url(), relative_url))
%{
"shortcode" => shortcode,
"static_url" => url,
"visible_in_picker" => true,
"url" => url,
"tags" => tags,
# Assuming that a comma is authorized in the category name
"category" => (tags -- ["Custom"]) |> Enum.join(",")
}
end)
end
def custom_emojis(conn, _params) do
mastodon_emoji = mastodonized_emoji()
2018-03-30 15:01:53 +02:00
json(conn, mastodon_emoji)
end
2019-09-30 14:10:54 +02:00
def follows(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
2019-04-15 11:37:49 +02:00
with {_, %User{} = followed} <- {:followed, User.get_cached_by_nickname(uri)},
{_, true} <- {:followed, follower.id != followed.id},
{:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
2018-12-16 17:49:42 +01:00
conn
|> put_view(AccountView)
2019-09-30 14:10:54 +02:00
|> render("show.json", %{user: followed, for: follower})
2017-10-28 23:07:38 +02:00
else
{:followed, _} ->
{:error, :not_found}
2017-11-19 02:22:07 +01:00
{:error, message} ->
2017-10-28 23:07:38 +02:00
conn
|> put_status(:forbidden)
|> json(%{error: message})
2017-10-28 23:07:38 +02:00
end
end
def mutes(%{assigns: %{user: user}} = conn, _) do
with muted_accounts <- User.muted_users(user) do
2019-09-30 14:10:54 +02:00
res = AccountView.render("index.json", users: muted_accounts, for: user, as: :user)
json(conn, res)
end
end
2017-11-03 08:51:17 +01:00
def blocks(%{assigns: %{user: user}} = conn, _) do
with blocked_accounts <- User.blocked_users(user) do
2019-09-30 14:10:54 +02:00
res = AccountView.render("index.json", users: blocked_accounts, for: user, as: :user)
2017-11-03 08:51:17 +01:00
json(conn, res)
end
end
def favourites(%{assigns: %{user: user}} = conn, params) do
2018-03-30 15:01:53 +02:00
params =
params
2018-03-30 15:01:53 +02:00
|> Map.put("type", "Create")
|> Map.put("favorited_by", user.ap_id)
|> Map.put("blocking_user", user)
2018-03-30 15:01:53 +02:00
activities =
ActivityPub.fetch_activities([], params)
2018-03-30 15:01:53 +02:00
|> Enum.reverse()
conn
|> add_link_headers(activities)
2018-12-16 17:49:42 +01:00
|> put_view(StatusView)
|> render("index.json", %{activities: activities, for: user, as: :activity})
end
2019-04-14 14:45:56 +02:00
def bookmarks(%{assigns: %{user: user}} = conn, params) do
2019-04-22 09:20:43 +02:00
user = User.get_cached_by_id(user.id)
2019-04-14 14:45:56 +02:00
bookmarks =
Bookmark.for_user_query(user.id)
|> Pagination.fetch_paginated(params)
2018-09-19 02:04:56 +02:00
activities =
2019-04-14 14:45:56 +02:00
bookmarks
|> Enum.map(fn b -> Map.put(b.activity, :bookmark, Map.delete(b, :activity)) end)
2018-09-19 02:04:56 +02:00
conn
|> add_link_headers(bookmarks)
2018-09-19 02:04:56 +02:00
|> put_view(StatusView)
|> render("index.json", %{activities: activities, for: user, as: :activity})
end
2017-11-12 14:23:05 +01:00
def index(%{assigns: %{user: user}} = conn, _params) do
token = get_session(conn, :oauth_token)
2017-11-12 14:23:05 +01:00
if user && token do
mastodon_emoji = mastodonized_emoji()
2018-09-22 04:48:42 +02:00
2019-02-03 18:44:18 +01:00
limit = Config.get([:instance, :limit])
2019-09-30 14:10:54 +02:00
accounts = Map.put(%{}, user.id, AccountView.render("show.json", %{user: user, for: user}))
2018-03-30 15:01:53 +02:00
initial_state =
%{
meta: %{
streaming_api_base_url: Pleroma.Web.Endpoint.websocket_url(),
2018-03-30 15:01:53 +02:00
access_token: token,
locale: "en",
domain: Pleroma.Web.Endpoint.host(),
admin: "1",
me: "#{user.id}",
unfollow_modal: false,
boost_modal: false,
delete_modal: true,
auto_play_gif: false,
2018-06-04 17:44:08 +02:00
display_sensitive_media: false,
reduce_motion: false,
max_toot_chars: limit,
mascot: User.get_mascot(user)["url"]
2017-11-12 14:23:05 +01:00
},
poll_limits: Config.get([:instance, :poll_limits]),
rights: %{
2019-02-03 18:44:18 +01:00
delete_others_notice: present?(user.info.is_moderator),
admin: present?(user.info.is_admin)
},
2018-03-30 15:01:53 +02:00
compose: %{
me: "#{user.id}",
2018-11-20 20:12:39 +01:00
default_privacy: user.info.default_scope,
default_sensitive: false,
allow_content_types: Config.get([:instance, :allowed_post_formats])
2018-03-30 15:01:53 +02:00
},
media_attachments: %{
accept_content_types: [
".jpg",
".jpeg",
".png",
".gif",
".webm",
".mp4",
".m4v",
"image\/jpeg",
"image\/png",
"image\/gif",
"video\/webm",
"video\/mp4"
]
},
2018-04-10 18:38:52 +02:00
settings:
user.info.settings ||
2018-04-10 18:38:52 +02:00
%{
onboarded: true,
home: %{
shows: %{
reblog: true,
reply: true
}
},
notifications: %{
alerts: %{
follow: true,
favourite: true,
reblog: true,
mention: true
},
shows: %{
follow: true,
favourite: true,
reblog: true,
mention: true
},
sounds: %{
follow: true,
favourite: true,
reblog: true,
mention: true
}
}
2018-03-30 15:01:53 +02:00
},
push_subscription: nil,
accounts: accounts,
custom_emojis: mastodon_emoji,
char_limit: limit
2018-03-30 15:01:53 +02:00
}
|> Jason.encode!()
2017-11-12 14:23:05 +01:00
conn
|> put_layout(false)
2018-12-16 17:49:42 +01:00
|> put_view(MastodonView)
2019-06-01 01:42:46 +02:00
|> render("index.html", %{initial_state: initial_state})
2017-11-12 14:23:05 +01:00
else
conn
|> put_session(:return_to, conn.request_path)
2017-11-12 14:23:05 +01:00
|> redirect(to: "/web/login")
end
end
def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
2019-09-24 09:49:02 +02:00
with {:ok, _} <- User.update_info(user, &User.Info.mastodon_settings_update(&1, settings)) do
2018-12-09 10:12:48 +01:00
json(conn, %{})
2018-04-10 18:38:52 +02:00
else
e ->
conn
|> put_status(:internal_server_error)
|> json(%{error: inspect(e)})
end
end
def login(%{assigns: %{user: %User{}}} = conn, _params) do
redirect(conn, to: local_mastodon_root_path(conn))
end
@doc "Local Mastodon FE login init action"
def login(conn, %{"code" => auth_token}) do
with {:ok, app} <- get_or_make_app(),
2019-09-06 20:50:00 +02:00
{:ok, auth} <- Authorization.get_by_token(app, auth_token),
{:ok, token} <- Token.exchange_token(app, auth) do
conn
|> put_session(:oauth_token, token.token)
|> redirect(to: local_mastodon_root_path(conn))
end
end
@doc "Local Mastodon FE callback action"
2017-11-19 02:22:07 +01:00
def login(conn, _) do
with {:ok, app} <- get_or_make_app() do
path =
2019-09-06 20:50:00 +02:00
o_auth_path(conn, :authorize,
response_type: "code",
client_id: app.client_id,
redirect_uri: ".",
scope: Enum.join(app.scopes, " ")
)
redirect(conn, to: path)
end
2017-11-12 14:23:05 +01:00
end
defp local_mastodon_root_path(conn) do
case get_session(conn, :return_to) do
nil ->
mastodon_api_path(conn, :index, ["getting-started"])
return_to ->
delete_session(conn, :return_to)
return_to
end
2017-11-12 14:23:05 +01:00
end
2019-09-06 20:50:00 +02:00
@spec get_or_make_app() :: {:ok, App.t()} | {:error, Ecto.Changeset.t()}
defp get_or_make_app do
2019-09-06 20:50:00 +02:00
App.get_or_make(
%{client_name: @local_mastodon_name, redirect_uris: "."},
["read", "write", "follow", "push"]
)
2017-11-12 14:23:05 +01:00
end
2017-11-19 13:23:16 +01:00
def logout(conn, _) do
conn
|> clear_session
|> redirect(to: "/")
end
2019-09-06 20:50:00 +02:00
# Stubs for unimplemented mastodon api
#
def empty_array(conn, _) do
Logger.debug("Unimplemented, returning an empty array")
json(conn, [])
end
def empty_object(conn, _) do
Logger.debug("Unimplemented, returning an empty object")
2018-08-14 04:27:28 +02:00
json(conn, %{})
end
def password_reset(conn, params) do
nickname_or_email = params["email"] || params["nickname"]
with {:ok, _} <- TwitterAPI.password_reset(nickname_or_email) do
conn
|> put_status(:no_content)
|> json("")
else
{:error, "unknown user"} ->
send_resp(conn, :not_found, "")
{:error, _} ->
send_resp(conn, :bad_request, "")
end
end
2019-02-03 18:44:18 +01:00
defp present?(nil), do: false
defp present?(false), do: false
defp present?(_), do: true
end