No OneTemporary
Actions

Authored By

Unknown

Size

26 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/api_spec/cast_and_validate.ex b/lib/pleroma/web/api_spec/cast_and_validate.ex
	new file mode 100644
	index 000000000..f36cf7a55
	--- /dev/null
	+++ b/lib/pleroma/web/api_spec/cast_and_validate.ex
	@@ -0,0 +1,120 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ApiSpec.CastAndValidate do
	+ @moduledoc """
	+ This plug is based on [`OpenApiSpex.Plug.CastAndValidate`]
	+ (https://github.com/open-api-spex/open_api_spex/blob/master/lib/open_api_spex/plug/cast_and_validate.ex).
	+ The main difference is ignoring unexpected query params
	+ instead of throwing an error. Also, the default rendering
	+ error module is `Pleroma.Web.ApiSpec.RenderError`.
	+ """
	+
	+ @behaviour Plug
	+
	+ alias Plug.Conn
	+
	+ @impl Plug
	+ def init(opts) do
	+ opts
	+ \|> Map.new()
	+ \|> Map.put_new(:render_error, Pleroma.Web.ApiSpec.RenderError)
	+ end
	+
	+ @impl Plug
	+ def call(%{private: %{open_api_spex: private_data}} = conn, %{
	+ operation_id: operation_id,
	+ render_error: render_error
	+ }) do
	+ spec = private_data.spec
	+ operation = private_data.operation_lookup[operation_id]
	+
	+ content_type =
	+ case Conn.get_req_header(conn, "content-type") do
	+ [header_value \| _] ->
	+ header_value
	+ \|> String.split(";")
	+ \|> List.first()
	+
	+ _ ->
	+ nil
	+ end
	+
	+ private_data = Map.put(private_data, :operation_id, operation_id)
	+ conn = Conn.put_private(conn, :open_api_spex, private_data)
	+
	+ case cast_and_validate(spec, operation, conn, content_type) do
	+ {:ok, conn} ->
	+ conn
	+
	+ {:error, reason} ->
	+ opts = render_error.init(reason)
	+
	+ conn
	+ \|> render_error.call(opts)
	+ \|> Plug.Conn.halt()
	+ end
	+ end
	+
	+ def call(
	+ %{
	+ private: %{
	+ phoenix_controller: controller,
	+ phoenix_action: action,
	+ open_api_spex: private_data
	+ }
	+ } = conn,
	+ opts
	+ ) do
	+ operation =
	+ case private_data.operation_lookup[{controller, action}] do
	+ nil ->
	+ operation_id = controller.open_api_operation(action).operationId
	+ operation = private_data.operation_lookup[operation_id]
	+
	+ operation_lookup =
	+ private_data.operation_lookup
	+ \|> Map.put({controller, action}, operation)
	+
	+ OpenApiSpex.Plug.Cache.adapter().put(
	+ private_data.spec_module,
	+ {private_data.spec, operation_lookup}
	+ )
	+
	+ operation
	+
	+ operation ->
	+ operation
	+ end
	+
	+ if operation.operationId do
	+ call(conn, Map.put(opts, :operation_id, operation.operationId))
	+ else
	+ raise "operationId was not found in action API spec"
	+ end
	+ end
	+
	+ def call(conn, opts), do: OpenApiSpex.Plug.CastAndValidate.call(conn, opts)
	+
	+ defp cast_and_validate(spec, operation, conn, content_type) do
	+ case OpenApiSpex.cast_and_validate(spec, operation, conn, content_type) do
	+ {:ok, conn} ->
	+ {:ok, conn}
	+
	+ # Remove unexpected query params and cast/validate again
	+ {:error, errors} ->
	+ query_params =
	+ Enum.reduce(errors, conn.query_params, fn
	+ %{reason: :unexpected_field, name: name, path: [name]}, params ->
	+ Map.delete(params, name)
	+
	+ _, params ->
	+ params
	+ end)
	+
	+ conn = %Conn{conn \| query_params: query_params}
	+ OpenApiSpex.cast_and_validate(spec, operation, conn, content_type)
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	index 61b0e2f63..8458cbdd5 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	@@ -1,397 +1,397 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [
	add_link_headers: 2,
	truthy_param?: 1,
	assign_account_by_id: 2,
	json_response: 3,
	skip_relationships?: 1
	]

	alias Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.Plugs.RateLimiter
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.ListView
	alias Pleroma.Web.MastodonAPI.MastodonAPI
	alias Pleroma.Web.MastodonAPI.MastodonAPIController
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.TwitterAPI.TwitterAPI

	- plug(OpenApiSpex.Plug.CastAndValidate, render_error: Pleroma.Web.ApiSpec.RenderError)
	+ plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(:skip_plug, [OAuthScopesPlug, EnsurePublicOrAuthenticatedPlug] when action == :create)

	plug(:skip_plug, EnsurePublicOrAuthenticatedPlug when action in [:show, :statuses])

	plug(
	OAuthScopesPlug,
	%{fallback: :proceed_unauthenticated, scopes: ["read:accounts"]}
	when action in [:show, :followers, :following]
	)

	plug(
	OAuthScopesPlug,
	%{fallback: :proceed_unauthenticated, scopes: ["read:statuses"]}
	when action == :statuses
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:accounts"]}
	when action in [:verify_credentials, :endorsements, :identity_proofs]
	)

	plug(OAuthScopesPlug, %{scopes: ["write:accounts"]} when action == :update_credentials)

	plug(OAuthScopesPlug, %{scopes: ["read:lists"]} when action == :lists)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "read:blocks"]} when action == :blocks
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "write:blocks"]} when action in [:block, :unblock]
	)

	plug(OAuthScopesPlug, %{scopes: ["read:follows"]} when action == :relationships)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "write:follows"]} when action in [:follow_by_uri, :follow, :unfollow]
	)

	plug(OAuthScopesPlug, %{scopes: ["follow", "read:mutes"]} when action == :mutes)

	plug(OAuthScopesPlug, %{scopes: ["follow", "write:mutes"]} when action in [:mute, :unmute])

	@relationship_actions [:follow, :unfollow]
	@needs_account ~W(followers following lists follow unfollow mute unmute block unblock)a

	plug(
	RateLimiter,
	[name: :relation_id_action, params: ["id", "uri"]] when action in @relationship_actions
	)

	plug(RateLimiter, [name: :relations_actions] when action in @relationship_actions)
	plug(RateLimiter, [name: :app_account_creation] when action == :create)
	plug(:assign_account_by_id when action in @needs_account)

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.AccountOperation

	@doc "POST /api/v1/accounts"
	def create(%{assigns: %{app: app}, body_params: params} = conn, _params) do
	with :ok <- validate_email_param(params),
	:ok <- TwitterAPI.validate_captcha(app, params),
	{:ok, user} <- TwitterAPI.register_user(params, need_confirmation: true),
	{:ok, token} <- Token.create_token(app, user, %{scopes: app.scopes}) do
	json(conn, %{
	token_type: "Bearer",
	access_token: token.token,
	scope: app.scopes,
	created_at: Token.Utils.format_created_at(token)
	})
	else
	{:error, error} -> json_response(conn, :bad_request, %{error: error})
	end
	end

	def create(%{assigns: %{app: _app}} = conn, _) do
	render_error(conn, :bad_request, "Missing parameters")
	end

	def create(conn, _) do
	render_error(conn, :forbidden, "Invalid credentials")
	end

	defp validate_email_param(%{email: email}) when not is_nil(email), do: :ok

	defp validate_email_param(_) do
	case Pleroma.Config.get([:instance, :account_activation_required]) do
	true -> {:error, dgettext("errors", "Missing parameter: %{name}", name: "email")}
	_ -> :ok
	end
	end

	@doc "GET /api/v1/accounts/verify_credentials"
	def verify_credentials(%{assigns: %{user: user}} = conn, _) do
	chat_token = Phoenix.Token.sign(conn, "user socket", user.id)

	render(conn, "show.json",
	user: user,
	for: user,
	with_pleroma_settings: true,
	with_chat_token: chat_token
	)
	end

	@doc "PATCH /api/v1/accounts/update_credentials"
	def update_credentials(%{assigns: %{user: original_user}, body_params: params} = conn, _params) do
	user = original_user

	params =
	params
	\|> Enum.filter(fn {_, value} -> not is_nil(value) end)
	\|> Enum.into(%{})

	user_params =
	[
	:no_rich_text,
	:locked,
	:hide_followers_count,
	:hide_follows_count,
	:hide_followers,
	:hide_follows,
	:hide_favorites,
	:show_role,
	:skip_thread_containment,
	:allow_following_move,
	:discoverable
	]
	\|> Enum.reduce(%{}, fn key, acc ->
	add_if_present(acc, params, key, key, &{:ok, truthy_param?(&1)})
	end)
	\|> add_if_present(params, :display_name, :name)
	\|> add_if_present(params, :note, :bio)
	\|> add_if_present(params, :avatar, :avatar)
	\|> add_if_present(params, :header, :banner)
	\|> add_if_present(params, :pleroma_background_image, :background)
	\|> add_if_present(
	params,
	:fields_attributes,
	:raw_fields,
	&{:ok, normalize_fields_attributes(&1)}
	)
	\|> add_if_present(params, :pleroma_settings_store, :pleroma_settings_store)
	\|> add_if_present(params, :default_scope, :default_scope)
	\|> add_if_present(params, :actor_type, :actor_type)

	changeset = User.update_changeset(user, user_params)

	with {:ok, user} <- User.update_and_set_cache(changeset) do
	render(conn, "show.json", user: user, for: user, with_pleroma_settings: true)
	else
	_e -> render_error(conn, :forbidden, "Invalid request")
	end
	end

	defp add_if_present(map, params, params_field, map_field, value_function \\ &{:ok, &1}) do
	with true <- Map.has_key?(params, params_field),
	{:ok, new_value} <- value_function.(Map.get(params, params_field)) do
	Map.put(map, map_field, new_value)
	else
	_ -> map
	end
	end

	defp normalize_fields_attributes(fields) do
	if Enum.all?(fields, &is_tuple/1) do
	Enum.map(fields, fn {_, v} -> v end)
	else
	Enum.map(fields, fn
	%{} = field -> %{"name" => field.name, "value" => field.value}
	field -> field
	end)
	end
	end

	@doc "GET /api/v1/accounts/relationships"
	def relationships(%{assigns: %{user: user}} = conn, %{id: id}) do
	targets = User.get_all_by_ids(List.wrap(id))

	render(conn, "relationships.json", user: user, targets: targets)
	end

	# Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array.
	def relationships(%{assigns: %{user: _user}} = conn, _), do: json(conn, [])

	@doc "GET /api/v1/accounts/:id"
	def show(%{assigns: %{user: for_user}} = conn, %{id: nickname_or_id}) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname_or_id, for: for_user),
	true <- User.visible_for?(user, for_user) do
	render(conn, "show.json", user: user, for: for_user)
	else
	_e -> render_error(conn, :not_found, "Can't find user")
	end
	end

	@doc "GET /api/v1/accounts/:id/statuses"
	def statuses(%{assigns: %{user: reading_user}} = conn, params) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(params.id, for: reading_user),
	true <- User.visible_for?(user, reading_user) do
	params =
	params
	\|> Map.delete(:tagged)
	\|> Enum.filter(&(not is_nil(&1)))
	\|> Map.new(fn {key, value} -> {to_string(key), value} end)
	\|> Map.put("tag", params[:tagged])

	activities = ActivityPub.fetch_user_activities(user, reading_user, params)

	conn
	\|> add_link_headers(activities)
	\|> put_view(StatusView)
	\|> render("index.json",
	activities: activities,
	for: reading_user,
	as: :activity,
	skip_relationships: skip_relationships?(params)
	)
	else
	_e -> render_error(conn, :not_found, "Can't find user")
	end
	end

	@doc "GET /api/v1/accounts/:id/followers"
	def followers(%{assigns: %{user: for_user, account: user}} = conn, params) do
	params =
	params
	\|> Enum.map(fn {key, value} -> {to_string(key), value} end)
	\|> Enum.into(%{})

	followers =
	cond do
	for_user && user.id == for_user.id -> MastodonAPI.get_followers(user, params)
	user.hide_followers -> []
	true -> MastodonAPI.get_followers(user, params)
	end

	conn
	\|> add_link_headers(followers)
	\|> render("index.json", for: for_user, users: followers, as: :user)
	end

	@doc "GET /api/v1/accounts/:id/following"
	def following(%{assigns: %{user: for_user, account: user}} = conn, params) do
	params =
	params
	\|> Enum.map(fn {key, value} -> {to_string(key), value} end)
	\|> Enum.into(%{})

	followers =
	cond do
	for_user && user.id == for_user.id -> MastodonAPI.get_friends(user, params)
	user.hide_follows -> []
	true -> MastodonAPI.get_friends(user, params)
	end

	conn
	\|> add_link_headers(followers)
	\|> render("index.json", for: for_user, users: followers, as: :user)
	end

	@doc "GET /api/v1/accounts/:id/lists"
	def lists(%{assigns: %{user: user, account: account}} = conn, _params) do
	lists = Pleroma.List.get_lists_account_belongs(user, account)

	conn
	\|> put_view(ListView)
	\|> render("index.json", lists: lists)
	end

	@doc "POST /api/v1/accounts/:id/follow"
	def follow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
	{:error, "Can not follow yourself"}
	end

	def follow(%{assigns: %{user: follower, account: followed}} = conn, params) do
	with {:ok, follower} <- MastodonAPI.follow(follower, followed, params) do
	render(conn, "relationship.json", user: follower, target: followed)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unfollow"
	def unfollow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
	{:error, "Can not unfollow yourself"}
	end

	def unfollow(%{assigns: %{user: follower, account: followed}} = conn, _params) do
	with {:ok, follower} <- CommonAPI.unfollow(follower, followed) do
	render(conn, "relationship.json", user: follower, target: followed)
	end
	end

	@doc "POST /api/v1/accounts/:id/mute"
	def mute(%{assigns: %{user: muter, account: muted}, body_params: params} = conn, _params) do
	with {:ok, _user_relationships} <- User.mute(muter, muted, params.notifications) do
	render(conn, "relationship.json", user: muter, target: muted)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unmute"
	def unmute(%{assigns: %{user: muter, account: muted}} = conn, _params) do
	with {:ok, _user_relationships} <- User.unmute(muter, muted) do
	render(conn, "relationship.json", user: muter, target: muted)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/block"
	def block(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
	with {:ok, _user_block} <- User.block(blocker, blocked),
	{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	render(conn, "relationship.json", user: blocker, target: blocked)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unblock"
	def unblock(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
	with {:ok, _user_block} <- User.unblock(blocker, blocked),
	{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
	render(conn, "relationship.json", user: blocker, target: blocked)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/follows"
	def follow_by_uri(%{body_params: %{uri: uri}} = conn, _) do
	case User.get_cached_by_nickname(uri) do
	%User{} = user ->
	conn
	\|> assign(:account, user)
	\|> follow(%{})

	nil ->
	{:error, :not_found}
	end
	end

	@doc "GET /api/v1/mutes"
	def mutes(%{assigns: %{user: user}} = conn, _) do
	users = User.muted_users(user, _restrict_deactivated = true)
	render(conn, "index.json", users: users, for: user, as: :user)
	end

	@doc "GET /api/v1/blocks"
	def blocks(%{assigns: %{user: user}} = conn, _) do
	users = User.blocked_users(user, _restrict_deactivated = true)
	render(conn, "index.json", users: users, for: user, as: :user)
	end

	@doc "GET /api/v1/endorsements"
	def endorsements(conn, params), do: MastodonAPIController.empty_array(conn, params)

	@doc "GET /api/v1/identity_proofs"
	def identity_proofs(conn, params), do: MastodonAPIController.empty_array(conn, params)
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/app_controller.ex b/lib/pleroma/web/mastodon_api/controllers/app_controller.ex
	index 408e11474..a516b6c20 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/app_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/app_controller.ex
	@@ -1,53 +1,53 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AppController do
	use Pleroma.Web, :controller

	alias Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Scopes
	alias Pleroma.Web.OAuth.Token

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	plug(
	:skip_plug,
	[OAuthScopesPlug, EnsurePublicOrAuthenticatedPlug]
	when action == :create
	)

	plug(OAuthScopesPlug, %{scopes: ["read"]} when action == :verify_credentials)

	- plug(OpenApiSpex.Plug.CastAndValidate)
	+ plug(Pleroma.Web.ApiSpec.CastAndValidate)

	@local_mastodon_name "Mastodon-Local"

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.AppOperation

	@doc "POST /api/v1/apps"
	def create(%{body_params: params} = conn, _params) do
	scopes = Scopes.fetch_scopes(params, ["read"])

	app_attrs =
	params
	\|> Map.take([:client_name, :redirect_uris, :website])
	\|> 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
	render(conn, "show.json", app: app)
	end
	end

	@doc "GET /api/v1/apps/verify_credentials"
	def verify_credentials(%{assigns: %{user: _user, token: token}} = conn, _) do
	with %Token{app: %App{} = app} <- Repo.preload(token, :app) do
	render(conn, "short.json", app: app)
	end
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/custom_emoji_controller.ex b/lib/pleroma/web/mastodon_api/controllers/custom_emoji_controller.ex
	index 000ad743f..c5f47c5df 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/custom_emoji_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/custom_emoji_controller.ex
	@@ -1,21 +1,21 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.CustomEmojiController do
	use Pleroma.Web, :controller

	- plug(OpenApiSpex.Plug.CastAndValidate)
	+ plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	:skip_plug,
	[Pleroma.Plugs.OAuthScopesPlug, Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug]
	when action == :index
	)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.CustomEmojiOperation

	def index(conn, _params) do
	render(conn, "index.json", custom_emojis: Pleroma.Emoji.get_all())
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/domain_block_controller.ex b/lib/pleroma/web/mastodon_api/controllers/domain_block_controller.ex
	index c4fa383f2..825b231ab 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/domain_block_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/domain_block_controller.ex
	@@ -1,40 +1,40 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.DomainBlockController do
	use Pleroma.Web, :controller

	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.User

	- plug(OpenApiSpex.Plug.CastAndValidate)
	+ plug(Pleroma.Web.ApiSpec.CastAndValidate)
	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.DomainBlockOperation

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "read:blocks"]} when action == :index
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "write:blocks"]} when action != :index
	)

	@doc "GET /api/v1/domain_blocks"
	def index(%{assigns: %{user: user}} = conn, _) do
	json(conn, Map.get(user, :domain_blocks, []))
	end

	@doc "POST /api/v1/domain_blocks"
	def create(%{assigns: %{user: blocker}, body_params: %{domain: domain}} = conn, _params) do
	User.block_domain(blocker, domain)
	json(conn, %{})
	end

	@doc "DELETE /api/v1/domain_blocks"
	def delete(%{assigns: %{user: blocker}, body_params: %{domain: domain}} = conn, _params) do
	User.unblock_domain(blocker, domain)
	json(conn, %{})
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex b/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex
	index a14c86893..596b85617 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex
	@@ -1,99 +1,99 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.NotificationController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2, skip_relationships?: 1]

	alias Pleroma.Notification
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.Web.MastodonAPI.MastodonAPI

	@oauth_read_actions [:show, :index]

	- plug(OpenApiSpex.Plug.CastAndValidate, render_error: Pleroma.Web.ApiSpec.RenderError)
	+ plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:notifications"]} when action in @oauth_read_actions
	)

	plug(OAuthScopesPlug, %{scopes: ["write:notifications"]} when action not in @oauth_read_actions)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.NotificationOperation

	# GET /api/v1/notifications
	def index(conn, %{account_id: account_id} = params) do
	case Pleroma.User.get_cached_by_id(account_id) do
	%{ap_id: account_ap_id} ->
	params =
	params
	\|> Map.delete(:account_id)
	\|> Map.put(:account_ap_id, account_ap_id)

	index(conn, params)

	_ ->
	conn
	\|> put_status(:not_found)
	\|> json(%{"error" => "Account is not found"})
	end
	end

	def index(%{assigns: %{user: user}} = conn, params) do
	params = Map.new(params, fn {k, v} -> {to_string(k), v} end)
	notifications = MastodonAPI.get_notifications(user, params)

	conn
	\|> add_link_headers(notifications)
	\|> render("index.json",
	notifications: notifications,
	for: user,
	skip_relationships: skip_relationships?(params)
	)
	end

	# GET /api/v1/notifications/:id
	def show(%{assigns: %{user: user}} = conn, %{id: id}) do
	with {:ok, notification} <- Notification.get(user, id) do
	render(conn, "show.json", notification: notification, for: user)
	else
	{:error, reason} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{"error" => reason})
	end
	end

	# POST /api/v1/notifications/clear
	def clear(%{assigns: %{user: user}} = conn, _params) do
	Notification.clear(user)
	json(conn, %{})
	end

	# POST /api/v1/notifications/:id/dismiss

	def dismiss(%{assigns: %{user: user}} = conn, %{id: id} = _params) do
	with {:ok, _notif} <- Notification.dismiss(user, id) do
	json(conn, %{})
	else
	{:error, reason} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{"error" => reason})
	end
	end

	# POST /api/v1/notifications/dismiss (deprecated)
	def dismiss_via_body(%{body_params: params} = conn, _) do
	dismiss(conn, params)
	end

	# DELETE /api/v1/notifications/destroy_multiple
	def destroy_multiple(%{assigns: %{user: user}} = conn, %{ids: ids} = _params) do
	Notification.destroy_multiple(user, ids)
	json(conn, %{})
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/report_controller.ex b/lib/pleroma/web/mastodon_api/controllers/report_controller.ex
	index f65c5c62b..405167108 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/report_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/report_controller.ex
	@@ -1,23 +1,23 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.ReportController do
	alias Pleroma.Plugs.OAuthScopesPlug

	use Pleroma.Web, :controller

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	- plug(OpenApiSpex.Plug.CastAndValidate, render_error: Pleroma.Web.ApiSpec.RenderError)
	+ plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(OAuthScopesPlug, %{scopes: ["write:reports"]} when action == :create)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.ReportOperation

	@doc "POST /api/v1/reports"
	def create(%{assigns: %{user: user}, body_params: params} = conn, _) do
	with {:ok, activity} <- Pleroma.Web.CommonAPI.report(user, params) do
	render(conn, "show.json", activity: activity)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 31, 5:01 AM (21 h, 15 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1801059
Default Alt Text: (26 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions