No OneTemporary
Actions

Size

24 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/admin_api/controllers/user_controller.ex b/lib/pleroma/web/admin_api/controllers/user_controller.ex
	index 7b4ee46a4..3de728ebf 100644
	--- a/lib/pleroma/web/admin_api/controllers/user_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/user_controller.ex
	@@ -1,309 +1,309 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.UserController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [fetch_integer_param: 3]

	alias Pleroma.ModerationLog
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.AdminAPI
	alias Pleroma.Web.AdminAPI.Search
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	@users_page_size 50

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

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

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:write:accounts"]}
	when action in [
	:delete,
	:create,
	:toggle_activation,
	:activate,
	:deactivate,
	:approve,
	:suggest,
	:unsuggest
	]
	)

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

	action_fallback(AdminAPI.FallbackController)

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

	def delete(conn, %{nickname: nickname}) do
	conn
	- \|> Map.put(:body_params, %{nicknames: [nickname]})
	+ \|> Map.put(:body_params, %{"nicknames" => [nickname]})
	\|> delete(%{})
	end

	- def delete(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def delete(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)

	Enum.each(users, fn user ->
	{:ok, delete_data, _} = Builder.delete(admin, user.ap_id)
	Pipeline.common_pipeline(delete_data, local: true)
	end)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "delete"
	})

	json(conn, nicknames)
	end

	def follow(
	%{
	assigns: %{user: admin},
	body_params: %{
	- follower: follower_nick,
	- followed: followed_nick
	+ "follower" => follower_nick,
	+ "followed" => followed_nick
	}
	} = conn,
	_
	) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.follow(follower, followed)

	ModerationLog.insert_log(%{
	actor: admin,
	followed: followed,
	follower: follower,
	action: "follow"
	})
	end

	json(conn, "ok")
	end

	def unfollow(
	%{
	assigns: %{user: admin},
	body_params: %{
	- follower: follower_nick,
	- followed: followed_nick
	+ "follower" => follower_nick,
	+ "followed" => followed_nick
	}
	} = conn,
	_
	) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.unfollow(follower, followed)

	ModerationLog.insert_log(%{
	actor: admin,
	followed: followed,
	follower: follower,
	action: "unfollow"
	})
	end

	json(conn, "ok")
	end

	- def create(%{assigns: %{user: admin}, body_params: %{users: users}} = conn, _) do
	+ def create(%{assigns: %{user: admin}, body_params: %{"users" => users}} = conn, _) do
	changesets =
	users
	\|> Enum.map(fn %{nickname: nickname, email: email, password: password} ->
	user_data = %{
	nickname: nickname,
	name: nickname,
	email: email,
	password: password,
	password_confirmation: password,
	bio: "."
	}

	User.register_changeset(%User{}, user_data, need_confirmation: false)
	end)
	\|> Enum.reduce(Ecto.Multi.new(), fn changeset, multi ->
	Ecto.Multi.insert(multi, Ecto.UUID.generate(), changeset)
	end)

	case Pleroma.Repo.transaction(changesets) do
	{:ok, users_map} ->
	users =
	users_map
	\|> Map.values()
	\|> Enum.map(fn user ->
	{:ok, user} = User.post_register_action(user)

	user
	end)

	ModerationLog.insert_log(%{
	actor: admin,
	subjects: users,
	action: "create"
	})

	render(conn, "created_many.json", users: users)

	{:error, id, changeset, _} ->
	changesets =
	Enum.map(changesets.operations, fn
	{^id, {:changeset, _current_changeset, _}} ->
	changeset

	{_, {:changeset, current_changeset, _}} ->
	current_changeset
	end)

	conn
	\|> put_status(:conflict)
	\|> render("create_errors.json", changesets: changesets)
	end
	end

	def show(%{assigns: %{user: admin}} = conn, %{nickname: nickname}) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname, for: admin) do
	render(conn, "show.json", %{user: user})
	else
	_ -> {:error, :not_found}
	end
	end

	def toggle_activation(%{assigns: %{user: admin}} = conn, %{nickname: nickname}) do
	user = User.get_cached_by_nickname(nickname)

	{:ok, updated_user} = User.set_activation(user, !user.is_active)

	action = if !user.is_active, do: "activate", else: "deactivate"

	ModerationLog.insert_log(%{
	actor: admin,
	subject: [user],
	action: action
	})

	render(conn, "show.json", user: updated_user)
	end

	- def activate(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def activate(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.set_activation(users, true)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "activate"
	})

	render(conn, "index.json", users: Keyword.values(updated_users))
	end

	- def deactivate(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def deactivate(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.set_activation(users, false)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "deactivate"
	})

	render(conn, "index.json", users: Keyword.values(updated_users))
	end

	- def approve(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def approve(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.approve(users)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "approve"
	})

	render(conn, "index.json", users: updated_users)
	end

	- def suggest(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def suggest(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.set_suggestion(users, true)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "add_suggestion"
	})

	render(conn, "index.json", users: updated_users)
	end

	- def unsuggest(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def unsuggest(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.set_suggestion(users, false)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "remove_suggestion"
	})

	render(conn, "index.json", users: updated_users)
	end

	def index(conn, params) do
	{page, page_size} = page_params(params)
	filters = maybe_parse_filters(params[:filters])

	search_params =
	%{
	query: params[:query],
	page: page,
	page_size: page_size,
	tags: params[:tags],
	name: params[:name],
	email: params[:email],
	actor_types: params[:actor_types]
	}
	\|> Map.merge(filters)

	with {:ok, users, count} <- Search.user(search_params) do
	render(conn, "index.json", users: users, count: count, page_size: page_size)
	end
	end

	@filters ~w(local external active deactivated need_approval unconfirmed is_admin is_moderator)

	@spec maybe_parse_filters(String.t()) :: %{required(String.t()) => true} \| %{}
	defp maybe_parse_filters(filters) when is_nil(filters) or filters == "", do: %{}

	defp maybe_parse_filters(filters) do
	filters
	\|> String.split(",")
	\|> Enum.filter(&Enum.member?(@filters, &1))
	\|> Map.new(&{String.to_existing_atom(&1), true})
	end

	defp page_params(params) do
	{
	fetch_integer_param(params, :page, 1),
	fetch_integer_param(params, :page_size, @users_page_size)
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/user_operation.ex b/lib/pleroma/web/api_spec/operations/admin/user_operation.ex
	index a5179ac39..49f5a4786 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/user_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/user_operation.ex
	@@ -1,453 +1,453 @@
	# 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.Admin.UserOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ActorType
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

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

	def index_operation do
	%Operation{
	tags: ["User administration"],
	summary: "List users",
	operationId: "AdminAPI.UserController.index",
	security: [%{"oAuth" => ["admin:read:accounts"]}],
	parameters: [
	Operation.parameter(:filters, :query, :string, "Comma separated list of filters"),
	Operation.parameter(:query, :query, :string, "Search users query"),
	Operation.parameter(:name, :query, :string, "Search by display name"),
	Operation.parameter(:email, :query, :string, "Search by email"),
	Operation.parameter(:page, :query, :integer, "Page Number"),
	Operation.parameter(:page_size, :query, :integer, "Number of users to return per page"),
	Operation.parameter(
	:actor_types,
	:query,
	%Schema{type: :array, items: ActorType},
	"Filter by actor type"
	),
	Operation.parameter(
	:tags,
	:query,
	%Schema{type: :array, items: %Schema{type: :string}},
	"Filter by tags"
	)
	\| admin_api_params()
	],
	responses: %{
	200 =>
	Operation.response(
	"Response",
	"application/json",
	%Schema{
	type: :object,
	properties: %{
	- users: %Schema{type: :array, items: user()},
	+ "users" => %Schema{type: :array, items: user()},
	count: %Schema{type: :integer},
	page_size: %Schema{type: :integer}
	}
	}
	),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def create_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Create a single or multiple users",
	operationId: "AdminAPI.UserController.create",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for creating users",
	type: :object,
	properties: %{
	- users: %Schema{
	+ "users" => %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	nickname: %Schema{type: :string},
	email: %Schema{type: :string},
	password: %Schema{type: :string}
	}
	}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	code: %Schema{type: :integer},
	type: %Schema{type: :string},
	data: %Schema{
	type: :object,
	properties: %{
	email: %Schema{type: :string, format: :email},
	nickname: %Schema{type: :string}
	}
	}
	}
	}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	409 =>
	Operation.response("Conflict", "application/json", %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	code: %Schema{type: :integer},
	error: %Schema{type: :string},
	type: %Schema{type: :string},
	data: %Schema{
	type: :object,
	properties: %{
	email: %Schema{type: :string, format: :email},
	nickname: %Schema{type: :string}
	}
	}
	}
	}
	})
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Show user",
	operationId: "AdminAPI.UserController.show",
	security: [%{"oAuth" => ["admin:read:accounts"]}],
	parameters: [
	Operation.parameter(
	:nickname,
	:path,
	:string,
	"User nickname or ID"
	)
	\| admin_api_params()
	],
	responses: %{
	200 => Operation.response("Response", "application/json", user()),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def follow_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Follow",
	operationId: "AdminAPI.UserController.follow",
	security: [%{"oAuth" => ["admin:write:follows"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	properties: %{
	- follower: %Schema{type: :string, description: "Follower nickname"},
	- followed: %Schema{type: :string, description: "Followed nickname"}
	+ "follower" => %Schema{type: :string, description: "Follower nickname"},
	+ "followed" => %Schema{type: :string, description: "Followed nickname"}
	}
	}
	),
	responses: %{
	200 => Operation.response("Response", "application/json", %Schema{type: :string}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def unfollow_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Unfollow",
	operationId: "AdminAPI.UserController.unfollow",
	security: [%{"oAuth" => ["admin:write:follows"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	properties: %{
	- follower: %Schema{type: :string, description: "Follower nickname"},
	- followed: %Schema{type: :string, description: "Followed nickname"}
	+ "follower" => %Schema{type: :string, description: "Follower nickname"},
	+ "followed" => %Schema{type: :string, description: "Followed nickname"}
	}
	}
	),
	responses: %{
	200 => Operation.response("Response", "application/json", %Schema{type: :string}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def approve_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Approve multiple users",
	operationId: "AdminAPI.UserController.approve",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for approving multiple users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{user: %Schema{type: :array, items: user()}}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def suggest_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Suggest multiple users",
	operationId: "AdminAPI.UserController.suggest",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for adding multiple suggested users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{user: %Schema{type: :array, items: user()}}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def unsuggest_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Unsuggest multiple users",
	operationId: "AdminAPI.UserController.unsuggest",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for removing multiple suggested users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{user: %Schema{type: :array, items: user()}}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def toggle_activation_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Toggle user activation",
	operationId: "AdminAPI.UserController.toggle_activation",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: [
	Operation.parameter(:nickname, :path, :string, "User nickname")
	\| admin_api_params()
	],
	responses: %{
	200 => Operation.response("Response", "application/json", user()),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def activate_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Activate multiple users",
	operationId: "AdminAPI.UserController.activate",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for deleting multiple users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{user: %Schema{type: :array, items: user()}}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def deactivate_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Deactivates multiple users",
	operationId: "AdminAPI.UserController.deactivate",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for deleting multiple users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{user: %Schema{type: :array, items: user()}}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Removes a single or multiple users",
	operationId: "AdminAPI.UserController.delete",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: [
	Operation.parameter(
	:nickname,
	:query,
	:string,
	"User nickname"
	)
	\| admin_api_params()
	],
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for deleting multiple users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	description: "Array of nicknames",
	type: :array,
	items: %Schema{type: :string}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	defp user do
	%Schema{
	type: :object,
	properties: %{
	id: %Schema{type: :string},
	email: %Schema{type: :string, format: :email},
	avatar: %Schema{type: :string, format: :uri},
	nickname: %Schema{type: :string},
	display_name: %Schema{type: :string},
	is_active: %Schema{type: :boolean},
	local: %Schema{type: :boolean},
	roles: %Schema{
	type: :object,
	properties: %{
	admin: %Schema{type: :boolean},
	moderator: %Schema{type: :boolean}
	}
	},
	tags: %Schema{type: :array, items: %Schema{type: :string}},
	is_confirmed: %Schema{type: :boolean},
	is_approved: %Schema{type: :boolean},
	url: %Schema{type: :string, format: :uri},
	registration_reason: %Schema{type: :string, nullable: true},
	actor_type: %Schema{type: :string}
	}
	}
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 25, 6:42 AM (1 d, 6 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 39699
Default Alt Text: (24 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions