No OneTemporary
Actions

Size

25 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex b/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex
	index 02b54d61a..724d873c0 100644
	--- a/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex
	@@ -1,442 +1,442 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.TwitterUtilOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def emoji_operation do
	%Operation{
	tags: ["Custom emojis"],
	summary: "List all custom emojis",
	operationId: "UtilController.emoji",
	parameters: [],
	responses: %{
	200 =>
	Operation.response("List", "application/json", %Schema{
	type: :object,
	additionalProperties: %Schema{
	type: :object,
	properties: %{
	image_url: %Schema{type: :string},
	tags: %Schema{type: :array, items: %Schema{type: :string}}
	},
	extensions: %{"x-additionalPropertiesName": "Emoji name"}
	},
	example: %{
	"firefox" => %{
	"image_url" => "/emoji/firefox.png",
	"tag" => ["Fun"]
	}
	}
	})
	}
	}
	end

	def frontend_configurations_operation do
	%Operation{
	tags: ["Others"],
	summary: "Dump frontend configurations",
	operationId: "UtilController.frontend_configurations",
	parameters: [],
	responses: %{
	200 =>
	Operation.response("List", "application/json", %Schema{
	type: :object,
	additionalProperties: %Schema{
	type: :object,
	description:
	"Opaque object representing the instance-wide configuration for the frontend",
	extensions: %{"x-additionalPropertiesName": "Frontend name"}
	}
	})
	}
	}
	end

	def change_password_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Change account password",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.change_password",
	requestBody: request_body("Parameters", change_password_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp change_password_request do
	%Schema{
	title: "ChangePasswordRequest",
	description: "POST body for changing the account's password",
	type: :object,
	required: [:password, :new_password, :new_password_confirmation],
	properties: %{
	password: %Schema{type: :string, description: "Current password"},
	new_password: %Schema{type: :string, description: "New password"},
	new_password_confirmation: %Schema{
	type: :string,
	description: "New password, confirmation"
	}
	}
	}
	end

	def change_email_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Change account email",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.change_email",
	requestBody: request_body("Parameters", change_email_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp change_email_request do
	%Schema{
	title: "ChangeEmailRequest",
	description: "POST body for changing the account's email",
	type: :object,
	required: [:email, :password],
	properties: %{
	email: %Schema{
	type: :string,
	description: "New email. Set to blank to remove the user's email."
	},
	password: %Schema{type: :string, description: "Current password"}
	}
	}
	end

	def update_notification_settings_operation do
	%Operation{
	tags: ["Settings"],
	summary: "Update Notification Settings",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.update_notification_settings",
	parameters: [
	Operation.parameter(
	:block_from_strangers,
	:query,
	BooleanLike.schema(),
	"blocks notifications from accounts you do not follow"
	),
	Operation.parameter(
	:hide_notification_contents,
	:query,
	BooleanLike.schema(),
	"removes the contents of a message from the push notification"
	)
	],
	requestBody: nil,
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def disable_account_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Disable Account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.disable_account",
	parameters: [
	Operation.parameter(:password, :query, :string, "Password")
	],
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def delete_account_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Delete Account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.delete_account",
	parameters: [
	Operation.parameter(:password, :query, :string, "Password")
	],
	requestBody: request_body("Parameters", delete_account_request(), required: false),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def captcha_operation do
	%Operation{
	summary: "Get a captcha",
	operationId: "UtilController.captcha",
	tags: ["Others"],
	parameters: [],
	responses: %{
	200 => Operation.response("Success", "application/json", %Schema{type: :object})
	}
	}
	end

	def move_account_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Move account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.move_account",
	requestBody: request_body("Parameters", move_account_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp move_account_request do
	%Schema{
	title: "MoveAccountRequest",
	description: "POST body for moving the account",
	type: :object,
	required: [:password, :target_account],
	properties: %{
	password: %Schema{type: :string, description: "Current password"},
	target_account: %Schema{
	type: :string,
	description: "The nickname of the target account to move to"
	}
	}
	}
	end

	def list_aliases_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "List account aliases",
	security: [%{"oAuth" => ["read:accounts"]}],
	operationId: "UtilController.list_aliases",
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{
	aliases: %Schema{
	type: :array,
	items: %Schema{type: :string},
	example: ["foo@example.org"]
	}
	}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def add_alias_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Add an alias to this account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.add_alias",
	requestBody: request_body("Parameters", add_alias_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{
	status: %Schema{
	type: :string,
	example: "success"
	}
	}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp add_alias_request do
	%Schema{
	title: "AddAliasRequest",
	description: "PUT body for adding aliases",
	type: :object,
	required: [:alias],
	properties: %{
	alias: %Schema{
	type: :string,
	description: "The nickname of the account to add to aliases"
	}
	}
	}
	end

	def delete_alias_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Delete an alias from this account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.delete_alias",
	requestBody: request_body("Parameters", delete_alias_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{
	status: %Schema{
	type: :string,
	example: "success"
	}
	}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp delete_alias_request do
	%Schema{
	title: "DeleteAliasRequest",
	description: "PUT body for deleting aliases",
	type: :object,
	required: [:alias],
	properties: %{
	alias: %Schema{
	type: :string,
	description: "The nickname of the account to delete from aliases"
	}
	}
	}
	end

	def healthcheck_operation do
	%Operation{
	tags: ["Others"],
	summary: "Quick status check on the instance",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.healthcheck",
	parameters: [],
	responses: %{
	200 => Operation.response("Healthy", "application/json", %Schema{type: :object}),
	503 =>
	Operation.response("Disabled or Unhealthy", "application/json", %Schema{type: :object})
	}
	}
	end

	def remote_subscribe_operation do
	%Operation{
	tags: ["Remote interaction"],
	summary: "Remote Subscribe",
	operationId: "UtilController.remote_subscribe",
	parameters: [],
	responses: %{200 => Operation.response("Web Page", "test/html", %Schema{type: :string})}
	}
	end

	def remote_interaction_operation do
	%Operation{
	tags: ["Remote interaction"],
	summary: "Remote interaction",
	operationId: "UtilController.remote_interaction",
	requestBody: request_body("Parameters", remote_interaction_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Remote interaction URL", "application/json", %Schema{type: :object})
	}
	}
	end

	defp remote_interaction_request do
	%Schema{
	title: "RemoteInteractionRequest",
	description: "POST body for remote interaction",
	type: :object,
	- required: ["ap_id", "profile"],
	+ required: [:ap_id, :profile],
	properties: %{
	- "ap_id" => %Schema{type: :string, description: "Profile or status ActivityPub ID"},
	- "profile" => %Schema{type: :string, description: "Remote profile webfinger"}
	+ ap_id: %Schema{type: :string, description: "Profile or status ActivityPub ID"},
	+ profile: %Schema{type: :string, description: "Remote profile webfinger"}
	}
	}
	end

	def show_subscribe_form_operation do
	%Operation{
	tags: ["Remote interaction"],
	summary: "Show remote subscribe form",
	operationId: "UtilController.show_subscribe_form",
	parameters: [],
	responses: %{200 => Operation.response("Web Page", "test/html", %Schema{type: :string})}
	}
	end

	defp delete_account_request do
	%Schema{
	title: "AccountDeleteRequest",
	description: "POST body for deleting one's own account",
	type: :object,
	properties: %{
	password: %Schema{
	type: :string,
	description: "The user's own password for confirmation.",
	format: :password
	}
	},
	example: %{
	"password" => "prettyp0ony1313"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/controllers/util_controller.ex b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	index a74c806a6..c8ecf5eff 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,371 +1,368 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.UtilController do
	use Pleroma.Web, :controller

	require Logger

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Emoji
	alias Pleroma.Healthcheck
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.WebFinger

	plug(
	Pleroma.Web.ApiSpec.CastAndValidate
	when action != :remote_subscribe and action != :show_subscribe_form
	)

	plug(
	Pleroma.Web.Plugs.FederatingPlug
	when action == :remote_subscribe
	when action == :show_subscribe_form
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:accounts"]}
	when action in [
	:change_email,
	:change_password,
	:delete_account,
	:update_notification_settings,
	:disable_account,
	:move_account,
	:add_alias,
	:delete_alias
	]
	)

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

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

	def show_subscribe_form(conn, %{"nickname" => nick}) do
	with %User{} = user <- User.get_cached_by_nickname(nick),
	avatar = User.avatar_url(user) do
	conn
	\|> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"remote follow error message - user not found",
	"Could not find user"
	)
	})
	end
	end

	def show_subscribe_form(conn, %{"status_id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	{:ok, ap_id} <- get_ap_id(activity),
	%User{} = user <- User.get_cached_by_ap_id(activity.actor),
	avatar = User.avatar_url(user) do
	conn
	\|> render("status_interact.html", %{
	status_link: ap_id,
	status_id: id,
	nickname: user.nickname,
	avatar: avatar,
	error: false
	})
	else
	_e ->
	render(conn, "status_interact.html", %{
	status_id: id,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"status interact error message - status not found",
	"Could not find status"
	)
	})
	end
	end

	def remote_subscribe(conn, %{"nickname" => nick, "profile" => _}) do
	show_subscribe_form(conn, %{"nickname" => nick})
	end

	def remote_subscribe(conn, %{"status_id" => id, "profile" => _}) do
	show_subscribe_form(conn, %{"status_id" => id})
	end

	def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	%User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
	conn
	\|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"remote follow error message - unknown error",
	"Something went wrong."
	)
	})
	end
	end

	def remote_subscribe(conn, %{"status" => %{"status_id" => id, "profile" => profile}}) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	%Activity{} = activity <- Activity.get_by_id(id),
	{:ok, ap_id} <- get_ap_id(activity) do
	conn
	\|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	else
	_e ->
	render(conn, "status_interact.html", %{
	status_id: id,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"status interact error message - unknown error",
	"Something went wrong."
	)
	})
	end
	end

	- def remote_interaction(
	- %{body_params: %{"ap_id" => ap_id, "profile" => profile}} = conn,
	- _params
	- ) do
	+ def remote_interaction(%{body_params: %{ap_id: ap_id, profile: profile}} = conn, _params) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile) do
	conn
	\|> json(%{url: String.replace(template, "{uri}", ap_id)})
	else
	_e -> json(conn, %{error: "Couldn't find user"})
	end
	end

	defp get_ap_id(activity) do
	object = Pleroma.Object.normalize(activity, fetch: false)

	case object do
	%{data: %{"id" => ap_id}} -> {:ok, ap_id}
	_ -> {:no_ap_id, nil}
	end
	end

	def frontend_configurations(conn, _params) do
	render(conn, "frontend_configurations.json")
	end

	def emoji(conn, _params) do
	emoji =
	Enum.reduce(Emoji.get_all(), %{}, fn {code, %Emoji{file: file, tags: tags}}, acc ->
	Map.put(acc, code, %{image_url: file, tags: tags})
	end)

	json(conn, emoji)
	end

	def update_notification_settings(%{assigns: %{user: user}} = conn, params) do
	with {:ok, _} <- User.update_notification_settings(user, params) do
	json(conn, %{status: "success"})
	end
	end

	def change_password(%{assigns: %{user: user}, body_params: body_params} = conn, %{}) do
	case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	{:ok, user} ->
	with {:ok, _user} <-
	User.reset_password(user, %{
	password: body_params.new_password,
	password_confirmation: body_params.new_password_confirmation
	}) do
	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "New password #{error}."})

	_ ->
	json(conn, %{error: "Unable to change password."})
	end

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def change_email(%{assigns: %{user: user}, body_params: body_params} = conn, %{}) do
	case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	{:ok, user} ->
	with {:ok, _user} <- User.change_email(user, body_params.email) do
	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "Email #{error}."})

	_ ->
	json(conn, %{error: "Unable to change email."})
	end

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def delete_account(%{assigns: %{user: user}, body_params: body_params} = conn, params) do
	# This endpoint can accept a query param or JSON body for backwards-compatibility.
	# Submitting a JSON body is recommended, so passwords don't end up in server logs.
	password = body_params[:password] \|\| params[:password] \|\| ""

	case CommonAPI.Utils.confirm_current_password(user, password) do
	{:ok, user} ->
	User.delete(user)
	json(conn, %{status: "success"})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def disable_account(%{assigns: %{user: user}} = conn, params) do
	case CommonAPI.Utils.confirm_current_password(user, params[:password]) do
	{:ok, user} ->
	User.set_activation_async(user, false)
	json(conn, %{status: "success"})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def move_account(%{assigns: %{user: user}, body_params: body_params} = conn, %{}) do
	case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	{:ok, user} ->
	with {:ok, target_user} <- find_or_fetch_user_by_nickname(body_params.target_account),
	{:ok, _user} <- ActivityPub.move(user, target_user) do
	json(conn, %{status: "success"})
	else
	{:not_found, _} ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Target account not found."})

	{:error, error} ->
	json(conn, %{error: error})
	end

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def add_alias(%{assigns: %{user: user}, body_params: body_params} = conn, _) do
	with {:ok, alias_user} <- find_user_by_nickname(body_params.alias),
	{:ok, _user} <- user \|> User.add_alias(alias_user) do
	json(conn, %{status: "success"})
	else
	{:not_found, _} ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Target account does not exist."})

	{:error, error} ->
	json(conn, %{error: error})
	end
	end

	def delete_alias(%{assigns: %{user: user}, body_params: body_params} = conn, _) do
	with {:ok, alias_user} <- find_user_by_nickname(body_params.alias),
	{:ok, _user} <- user \|> User.delete_alias(alias_user) do
	json(conn, %{status: "success"})
	else
	{:error, :no_such_alias} ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Account has no such alias."})

	{:error, error} ->
	json(conn, %{error: error})
	end
	end

	def list_aliases(%{assigns: %{user: user}} = conn, %{}) do
	alias_nicks =
	user
	\|> User.alias_users()
	\|> Enum.map(&User.full_nickname/1)

	json(conn, %{aliases: alias_nicks})
	end

	defp find_user_by_nickname(nickname) do
	user = User.get_cached_by_nickname(nickname)

	if user == nil do
	{:error, :not_found}
	else
	{:ok, user}
	end
	end

	defp find_or_fetch_user_by_nickname(nickname) do
	user = User.get_by_nickname(nickname)

	if user != nil and user.local do
	{:ok, user}
	else
	with {:ok, user} <- User.fetch_by_nickname(nickname) do
	{:ok, user}
	else
	_ ->
	{:not_found, nil}
	end
	end
	end

	def captcha(conn, _params) do
	json(conn, Pleroma.Captcha.new())
	end

	def healthcheck(conn, _params) do
	with {:cfg, true} <- {:cfg, Config.get([:instance, :healthcheck])},
	%{healthy: true} = info <- Healthcheck.system_info() do
	json(conn, info)
	else
	%{healthy: false} = info ->
	service_unavailable(conn, info)

	{:cfg, false} ->
	service_unavailable(conn, %{"error" => "Healthcheck disabled"})

	_ ->
	service_unavailable(conn, %{})
	end
	end

	defp service_unavailable(conn, info) do
	conn
	\|> put_status(:service_unavailable)
	\|> json(info)
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Tue, Oct 13, 11:14 AM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1786741
Default Alt Text: (25 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions