No OneTemporary
Actions

Authored By

Unknown

Size

29 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/ldap-password-change.add b/changelog.d/ldap-password-change.add
	new file mode 100644
	index 000000000..7ca555ee4
	--- /dev/null
	+++ b/changelog.d/ldap-password-change.add
	@@ -0,0 +1 @@
	+LDAP now supports users changing their passwords
	diff --git a/installation/openldap/pw_self_service.ldif b/installation/openldap/pw_self_service.ldif
	new file mode 100644
	index 000000000..463dabbfb
	--- /dev/null
	+++ b/installation/openldap/pw_self_service.ldif
	@@ -0,0 +1,7 @@
	+dn: olcDatabase={1}mdb,cn=config
	+changetype: modify
	+add: olcAccess
	+olcAccess: {1}to attrs=userPassword
	+ by self write
	+ by anonymous auth
	+ by * none
	diff --git a/lib/pleroma/ldap.ex b/lib/pleroma/ldap.ex
	index 46a2d0c17..b591c2918 100644
	--- a/lib/pleroma/ldap.ex
	+++ b/lib/pleroma/ldap.ex
	@@ -1,245 +1,271 @@
	defmodule Pleroma.LDAP do
	use GenServer

	require Logger

	alias Pleroma.Config
	alias Pleroma.User

	import Pleroma.Web.Auth.Helpers, only: [fetch_user: 1]

	@connection_timeout 2_000
	@search_timeout 2_000

	def start_link(_) do
	GenServer.start_link(__MODULE__, [], name: __MODULE__)
	end

	+ def bind_user(name, password) do
	+ GenServer.call(__MODULE__, {:bind_user, name, password})
	+ end
	+
	+ def change_password(name, password, new_password) do
	+ GenServer.call(__MODULE__, {:change_password, name, password, new_password})
	+ end
	+
	@impl true
	def init(state) do
	case {Config.get(Pleroma.Web.Auth.Authenticator), Config.get([:ldap, :enabled])} do
	{Pleroma.Web.Auth.LDAPAuthenticator, true} ->
	{:ok, state, {:continue, :connect}}

	{Pleroma.Web.Auth.LDAPAuthenticator, false} ->
	Logger.error(
	"LDAP Authenticator enabled but :pleroma, :ldap is not enabled. Auth will not work."
	)

	{:ok, state}

	{_, true} ->
	Logger.warning(
	":pleroma, :ldap is enabled but Pleroma.Web.Authenticator is not set to the LDAPAuthenticator. LDAP will not be used."
	)

	{:ok, state}

	_ ->
	{:ok, state}
	end
	end

	@impl true
	def handle_continue(:connect, _state), do: do_handle_connect()

	@impl true
	def handle_info(:connect, _state), do: do_handle_connect()

	def handle_info({:bind_after_reconnect, name, password, from}, state) do
	- result = bind_user(state[:handle], name, password)
	+ result = do_bind_user(state[:handle], name, password)

	GenServer.reply(from, result)

	{:noreply, state}
	end

	- defp do_handle_connect do
	- state =
	- case connect() do
	- {:ok, handle} ->
	- :eldap.controlling_process(handle, self())
	- Process.link(handle)
	- [handle: handle]
	-
	- _ ->
	- Logger.error("Failed to connect to LDAP. Retrying in 5000ms")
	- Process.send_after(self(), :connect, 5_000)
	- []
	- end
	-
	- {:noreply, state}
	- end
	-
	@impl true
	def handle_call({:bind_user, name, password}, from, state) do
	- case bind_user(state[:handle], name, password) do
	+ case do_bind_user(state[:handle], name, password) do
	:needs_reconnect ->
	Process.send(self(), {:bind_after_reconnect, name, password, from}, [])
	{:noreply, state, {:continue, :connect}}

	result ->
	{:reply, result, state, :hibernate}
	end
	end

	+ def handle_call({:change_password, name, password, new_password}, _from, state) do
	+ result = change_password(state[:handle], name, password, new_password)
	+
	+ {:reply, result, state, :hibernate}
	+ end
	+
	@impl true
	def terminate(_, state) do
	handle = Keyword.get(state, :handle)

	if not is_nil(handle) do
	:eldap.close(handle)
	end

	:ok
	end

	- def bind_user(name, password) do
	- GenServer.call(__MODULE__, {:bind_user, name, password})
	+ defp do_handle_connect do
	+ state =
	+ case connect() do
	+ {:ok, handle} ->
	+ :eldap.controlling_process(handle, self())
	+ Process.link(handle)
	+ [handle: handle]
	+
	+ _ ->
	+ Logger.error("Failed to connect to LDAP. Retrying in 5000ms")
	+ Process.send_after(self(), :connect, 5_000)
	+ []
	+ end
	+
	+ {:noreply, state}
	end

	defp connect do
	ldap = Config.get(:ldap, [])
	host = Keyword.get(ldap, :host, "localhost")
	port = Keyword.get(ldap, :port, 389)
	ssl = Keyword.get(ldap, :ssl, false)
	tls = Keyword.get(ldap, :tls, false)
	cacertfile = Keyword.get(ldap, :cacertfile) \|\| CAStore.file_path()

	if ssl, do: Application.ensure_all_started(:ssl)

	default_secure_opts = [
	verify: :verify_peer,
	cacerts: decode_certfile(cacertfile),
	customize_hostname_check: [
	fqdn_fun: fn _ -> to_charlist(host) end
	]
	]

	sslopts = Keyword.merge(default_secure_opts, Keyword.get(ldap, :sslopts, []))
	tlsopts = Keyword.merge(default_secure_opts, Keyword.get(ldap, :tlsopts, []))

	default_options = [{:port, port}, {:ssl, ssl}, {:timeout, @connection_timeout}]

	# :sslopts can only be included in :eldap.open/2 when {ssl: true}
	# or the connection will fail
	options =
	if ssl do
	default_options ++ [{:sslopts, sslopts}]
	else
	default_options
	end

	case :eldap.open([to_charlist(host)], options) do
	{:ok, handle} ->
	try do
	cond do
	tls ->
	case :eldap.start_tls(
	handle,
	tlsopts,
	@connection_timeout
	) do
	:ok ->
	{:ok, handle}

	error ->
	Logger.error("Could not start TLS: #{inspect(error)}")
	:eldap.close(handle)
	end

	true ->
	{:ok, handle}
	end
	after
	:ok
	end

	{:error, error} ->
	Logger.error("Could not open LDAP connection: #{inspect(error)}")
	{:error, {:ldap_connection_error, error}}
	end
	end

	- defp bind_user(handle, name, password) do
	- uid = Config.get([:ldap, :uid], "cn")
	- base = Config.get([:ldap, :base])
	+ defp do_bind_user(handle, name, password) do
	+ dn = make_dn(name)

	- case :eldap.simple_bind(handle, "#{uid}=#{name},#{base}", password) do
	+ case :eldap.simple_bind(handle, dn, password) do
	:ok ->
	case fetch_user(name) do
	%User{} = user ->
	user

	_ ->
	- register_user(handle, base, uid, name)
	+ register_user(handle, ldap_base(), ldap_uid(), name)
	end

	# eldap does not inform us of socket closure
	# until it is used
	{:error, {:gen_tcp_error, :closed}} ->
	:eldap.close(handle)
	:needs_reconnect

	{:error, error} = e ->
	Logger.error("Could not bind LDAP user #{name}: #{inspect(error)}")
	e
	end
	end

	defp register_user(handle, base, uid, name) do
	case :eldap.search(handle, [
	{:base, to_charlist(base)},
	{:filter, :eldap.equalityMatch(to_charlist(uid), to_charlist(name))},
	{:scope, :eldap.wholeSubtree()},
	{:timeout, @search_timeout}
	]) do
	# The :eldap_search_result record structure changed in OTP 24.3 and added a controls field
	# https://github.com/erlang/otp/pull/5538
	{:ok, {:eldap_search_result, [{:eldap_entry, _object, attributes}], _referrals}} ->
	try_register(name, attributes)

	{:ok, {:eldap_search_result, [{:eldap_entry, _object, attributes}], _referrals, _controls}} ->
	try_register(name, attributes)

	error ->
	Logger.error("Couldn't register user because LDAP search failed: #{inspect(error)}")
	{:error, {:ldap_search_error, error}}
	end
	end

	defp try_register(name, attributes) do
	mail_attribute = Config.get([:ldap, :mail])

	params = %{
	name: name,
	nickname: name,
	password: nil
	}

	params =
	case List.keyfind(attributes, to_charlist(mail_attribute), 0) do
	{_, [mail]} -> Map.put_new(params, :email, :erlang.list_to_binary(mail))
	_ -> params
	end

	changeset = User.register_changeset_ldap(%User{}, params)

	case User.register(changeset) do
	{:ok, user} -> user
	error -> error
	end
	end

	+ defp change_password(handle, name, password, new_password) do
	+ dn = make_dn(name)
	+
	+ with :ok <- :eldap.simple_bind(handle, dn, password) do
	+ :eldap.modify_password(handle, dn, to_charlist(new_password), to_charlist(password))
	+ end
	+ end
	+
	defp decode_certfile(file) do
	with {:ok, data} <- File.read(file) do
	data
	\|> :public_key.pem_decode()
	\|> Enum.map(fn {_, b, _} -> b end)
	else
	_ ->
	Logger.error("Unable to read certfile: #{file}")
	[]
	end
	end
	+
	+ defp ldap_uid, do: to_charlist(Config.get([:ldap, :uid], "cn"))
	+ defp ldap_base, do: to_charlist(Config.get([:ldap, :base]))
	+
	+ defp make_dn(name) do
	+ uid = ldap_uid()
	+ base = ldap_base()
	+ ~c"#{uid}=#{name},#{base}"
	+ end
	end
	diff --git a/lib/pleroma/web/auth/authenticator.ex b/lib/pleroma/web/auth/authenticator.ex
	index 01bf1575c..95be892cd 100644
	--- a/lib/pleroma/web/auth/authenticator.ex
	+++ b/lib/pleroma/web/auth/authenticator.ex
	@@ -1,13 +1,18 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.Authenticator do
	@callback get_user(Plug.Conn.t()) :: {:ok, user :: struct()} \| {:error, any()}
	@callback create_from_registration(Plug.Conn.t(), registration :: struct()) ::
	{:ok, Pleroma.User.t()} \| {:error, any()}
	@callback get_registration(Plug.Conn.t()) :: {:ok, registration :: struct()} \| {:error, any()}
	@callback handle_error(Plug.Conn.t(), any()) :: any()
	@callback auth_template() :: String.t() \| nil
	@callback oauth_consumer_template() :: String.t() \| nil
	+
	+ @callback change_password(Pleroma.User.t(), String.t(), String.t(), String.t()) ::
	+ {:ok, Pleroma.User.t()} \| {:error, term()}
	+
	+ @optional_callbacks change_password: 4
	end
	diff --git a/lib/pleroma/web/auth/ldap_authenticator.ex b/lib/pleroma/web/auth/ldap_authenticator.ex
	index 7eb06183d..ec6601fb9 100644
	--- a/lib/pleroma/web/auth/ldap_authenticator.ex
	+++ b/lib/pleroma/web/auth/ldap_authenticator.ex
	@@ -1,33 +1,42 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.LDAPAuthenticator do
	alias Pleroma.LDAP
	alias Pleroma.User

	import Pleroma.Web.Auth.Helpers, only: [fetch_credentials: 1]

	@behaviour Pleroma.Web.Auth.Authenticator
	@base Pleroma.Web.Auth.PleromaAuthenticator

	defdelegate get_registration(conn), to: @base
	defdelegate create_from_registration(conn, registration), to: @base
	defdelegate handle_error(conn, error), to: @base
	defdelegate auth_template, to: @base
	defdelegate oauth_consumer_template, to: @base

	def get_user(%Plug.Conn{} = conn) do
	with {:ldap, true} <- {:ldap, Pleroma.Config.get([:ldap, :enabled])},
	{:ok, {name, password}} <- fetch_credentials(conn),
	%User{} = user <- LDAP.bind_user(name, password) do
	{:ok, user}
	else
	{:ldap, _} ->
	@base.get_user(conn)

	error ->
	error
	end
	end
	+
	+ def change_password(user, password, new_password, new_password) do
	+ case LDAP.change_password(user.nickname, password, new_password) do
	+ :ok -> {:ok, user}
	+ e -> e
	+ end
	+ end
	+
	+ def change_password(_, _, _, _), do: {:error, :password_confirmation}
	end
	diff --git a/lib/pleroma/web/auth/pleroma_authenticator.ex b/lib/pleroma/web/auth/pleroma_authenticator.ex
	index 09a58eb66..0da3f19fc 100644
	--- a/lib/pleroma/web/auth/pleroma_authenticator.ex
	+++ b/lib/pleroma/web/auth/pleroma_authenticator.ex
	@@ -1,104 +1,124 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.PleromaAuthenticator do
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	+ alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.AuthenticationPlug

	import Pleroma.Web.Auth.Helpers, only: [fetch_credentials: 1, fetch_user: 1]

	@behaviour Pleroma.Web.Auth.Authenticator

	def get_user(%Plug.Conn{} = conn) do
	with {:ok, {name, password}} <- fetch_credentials(conn),
	{_, %User{} = user} <- {:user, fetch_user(name)},
	{_, true} <- {:checkpw, AuthenticationPlug.checkpw(password, user.password_hash)},
	{:ok, user} <- AuthenticationPlug.maybe_update_password(user, password) do
	{:ok, user}
	else
	{:error, _reason} = error -> error
	error -> {:error, error}
	end
	end

	@doc """
	Gets or creates Pleroma.Registration record from Ueberauth assigns.
	Note: some strategies (like `keycloak`) might need extra configuration to fill `uid` from callback response —
	see [`docs/config.md`](docs/config.md).
	"""
	def get_registration(%Plug.Conn{assigns: %{ueberauth_auth: %{uid: nil}}}),
	do: {:error, :missing_uid}

	def get_registration(%Plug.Conn{
	assigns: %{ueberauth_auth: %{provider: provider, uid: uid} = auth}
	}) do
	registration = Registration.get_by_provider_uid(provider, uid)

	if registration do
	{:ok, registration}
	else
	info = auth.info

	%Registration{}
	\|> Registration.changeset(%{
	provider: to_string(provider),
	uid: to_string(uid),
	info: %{
	"nickname" => info.nickname,
	"email" => info.email,
	"name" => info.name,
	"description" => info.description
	}
	})
	\|> Repo.insert()
	end
	end

	def get_registration(%Plug.Conn{} = _conn), do: {:error, :missing_credentials}

	@doc "Creates Pleroma.User record basing on params and Pleroma.Registration record."
	def create_from_registration(
	%Plug.Conn{params: %{"authorization" => registration_attrs}},
	%Registration{} = registration
	) do
	nickname = value([registration_attrs["nickname"], Registration.nickname(registration)])
	email = value([registration_attrs["email"], Registration.email(registration)])
	name = value([registration_attrs["name"], Registration.name(registration)]) \|\| nickname
	bio = value([registration_attrs["bio"], Registration.description(registration)]) \|\| ""

	random_password = :crypto.strong_rand_bytes(64) \|> Base.encode64()

	with {:ok, new_user} <-
	User.register_changeset(
	%User{},
	%{
	email: email,
	nickname: nickname,
	name: name,
	bio: bio,
	password: random_password,
	password_confirmation: random_password
	},
	external: true,
	confirmed: true
	)
	\|> Repo.insert(),
	{:ok, _} <-
	Registration.changeset(registration, %{user_id: new_user.id}) \|> Repo.update() do
	{:ok, new_user}
	end
	end

	defp value(list), do: Enum.find(list, &(to_string(&1) != ""))

	def handle_error(%Plug.Conn{} = _conn, error) do
	error
	end

	def auth_template, do: nil

	def oauth_consumer_template, do: nil
	+
	+ @doc "Changes Pleroma.User password in the database"
	+ def change_password(user, password, new_password, new_password) do
	+ case CommonAPI.Utils.confirm_current_password(user, password) do
	+ {:ok, user} ->
	+ with {:ok, _user} <-
	+ User.reset_password(user, %{
	+ password: new_password,
	+ password_confirmation: new_password
	+ }) do
	+ {:ok, user}
	+ end
	+
	+ error ->
	+ error
	+ end
	+ end
	+
	+ def change_password(_, _, _, _), do: {:error, :password_confirmation}
	end
	diff --git a/lib/pleroma/web/auth/wrapper_authenticator.ex b/lib/pleroma/web/auth/wrapper_authenticator.ex
	index a077cfa41..97b901036 100644
	--- a/lib/pleroma/web/auth/wrapper_authenticator.ex
	+++ b/lib/pleroma/web/auth/wrapper_authenticator.ex
	@@ -1,42 +1,46 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.WrapperAuthenticator do
	@behaviour Pleroma.Web.Auth.Authenticator

	defp implementation do
	Pleroma.Config.get(
	Pleroma.Web.Auth.Authenticator,
	Pleroma.Web.Auth.PleromaAuthenticator
	)
	end

	@impl true
	def get_user(plug), do: implementation().get_user(plug)

	@impl true
	def create_from_registration(plug, registration),
	do: implementation().create_from_registration(plug, registration)

	@impl true
	def get_registration(plug), do: implementation().get_registration(plug)

	@impl true
	def handle_error(plug, error),
	do: implementation().handle_error(plug, error)

	@impl true
	def auth_template do
	# Note: `config :pleroma, :auth_template, "..."` support is deprecated
	implementation().auth_template() \|\|
	Pleroma.Config.get([:auth, :auth_template], Pleroma.Config.get(:auth_template)) \|\|
	"show.html"
	end

	@impl true
	def oauth_consumer_template do
	implementation().oauth_consumer_template() \|\|
	Pleroma.Config.get([:auth, :oauth_consumer_template], "consumer.html")
	end
	+
	+ @impl true
	+ def change_password(user, password, new_password, new_password_confirmation),
	+ do: implementation().change_password(user, password, new_password, new_password_confirmation)
	end
	diff --git a/lib/pleroma/web/twitter_api/controllers/util_controller.ex b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	index 6805233df..aeafa195d 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,393 +1,396 @@
	# 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.Auth.WrapperAuthenticator, as: Authenticator
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.WebFinger

	plug(
	Pleroma.Web.ApiSpec.CastAndValidate,
	[replace_params: false]
	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(
	%{private: %{open_api_spex: %{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}, private: %{open_api_spex: %{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}."})
	- end
	+ with {:ok, %User{}} <-
	+ Authenticator.change_password(
	+ user,
	+ body_params.password,
	+ body_params.new_password,
	+ body_params.new_password_confirmation
	+ ) do
	+ json(conn, %{status: "success"})
	+ else
	+ {:error, %Ecto.Changeset{} = changeset} ->
	+ {_, {error, _}} = Enum.at(changeset.errors, 0)
	+ json(conn, %{error: "New password #{error}."})
	+
	+ {:error, :password_confirmation} ->
	+ json(conn, %{error: "New password does not match confirmation."})

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

	def change_email(
	%{assigns: %{user: user}, private: %{open_api_spex: %{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},
	private: %{open_api_spex: %{body_params: body_params, params: params}}
	} = conn,
	_
	) 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}, private: %{open_api_spex: %{params: params}}} = conn,
	_
	) 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}, private: %{open_api_spex: %{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}, private: %{open_api_spex: %{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}, private: %{open_api_spex: %{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: Thu, Oct 29, 9:34 PM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798692
Default Alt Text: (29 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions