No OneTemporary
Actions

Authored By

Unknown

Size

99 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex
	new file mode 100644
	index 000000000..b6932157a
	--- /dev/null
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex
	@@ -0,0 +1,133 @@
	+# 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.PleromaEmojiFileOperation do
	+ alias OpenApiSpex.Operation
	+ alias OpenApiSpex.Schema
	+ 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 create_operation do
	+ %Operation{
	+ tags: ["Emoji Packs"],
	+ summary: "Add new file to the pack",
	+ operationId: "PleromaAPI.EmojiPackController.add_file",
	+ security: [%{"oAuth" => ["write"]}],
	+ requestBody: request_body("Parameters", create_request(), required: true),
	+ parameters: [name_param()],
	+ responses: %{
	+ 200 => Operation.response("Files Object", "application/json", files_object()),
	+ 400 => Operation.response("Bad Request", "application/json", ApiError),
	+ 409 => Operation.response("Conflict", "application/json", ApiError)
	+ }
	+ }
	+ end
	+
	+ defp create_request do
	+ %Schema{
	+ type: :object,
	+ required: [:file],
	+ properties: %{
	+ file: %Schema{
	+ description:
	+ "File needs to be uploaded with the multipart request or link to remote file",
	+ anyOf: [
	+ %Schema{type: :string, format: :binary},
	+ %Schema{type: :string, format: :uri}
	+ ]
	+ },
	+ shortcode: %Schema{
	+ type: :string,
	+ description:
	+ "Shortcode for new emoji, must be unique for all emoji. If not sended, shortcode will be taken from original filename."
	+ },
	+ filename: %Schema{
	+ type: :string,
	+ description:
	+ "New emoji file name. If not specified will be taken from original filename."
	+ }
	+ }
	+ }
	+ end
	+
	+ def update_operation do
	+ %Operation{
	+ tags: ["Emoji Packs"],
	+ summary: "Add new file to the pack",
	+ operationId: "PleromaAPI.EmojiPackController.update_file",
	+ security: [%{"oAuth" => ["write"]}],
	+ requestBody: request_body("Parameters", update_request(), required: true),
	+ parameters: [name_param()],
	+ responses: %{
	+ 200 => Operation.response("Files Object", "application/json", files_object()),
	+ 400 => Operation.response("Bad Request", "application/json", ApiError),
	+ 409 => Operation.response("Conflict", "application/json", ApiError)
	+ }
	+ }
	+ end
	+
	+ defp update_request do
	+ %Schema{
	+ type: :object,
	+ required: [:shortcode, :new_shortcode, :new_filename],
	+ properties: %{
	+ shortcode: %Schema{
	+ type: :string,
	+ description: "Emoji file shortcode"
	+ },
	+ new_shortcode: %Schema{
	+ type: :string,
	+ description: "New emoji file shortcode"
	+ },
	+ new_filename: %Schema{
	+ type: :string,
	+ description: "New filename for emoji file"
	+ },
	+ force: %Schema{
	+ type: :boolean,
	+ description: "With true value to overwrite existing emoji with new shortcode",
	+ default: false
	+ }
	+ }
	+ }
	+ end
	+
	+ def delete_operation do
	+ %Operation{
	+ tags: ["Emoji Packs"],
	+ summary: "Delete emoji file from pack",
	+ operationId: "PleromaAPI.EmojiPackController.delete_file",
	+ security: [%{"oAuth" => ["write"]}],
	+ parameters: [
	+ name_param(),
	+ Operation.parameter(:shortcode, :query, :string, "File shortcode",
	+ example: "cofe",
	+ required: true
	+ )
	+ ],
	+ responses: %{
	+ 200 => Operation.response("Files Object", "application/json", files_object()),
	+ 400 => Operation.response("Bad Request", "application/json", ApiError)
	+ }
	+ }
	+ end
	+
	+ defp name_param do
	+ Operation.parameter(:name, :path, :string, "Pack Name", example: "cofe", required: true)
	+ end
	+
	+ defp files_object do
	+ %Schema{
	+ type: :object,
	+ additionalProperties: %Schema{type: :string},
	+ description: "Object with emoji names as keys and filenames as values"
	+ }
	+ end
	+end
	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex
	index b2b4f8713..59548af13 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex
	@@ -1,418 +1,313 @@
	# 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.PleromaEmojiPackOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	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 remote_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Make request to another instance for emoji packs list",
	security: [%{"oAuth" => ["write"]}],
	parameters: [url_param()],
	operationId: "PleromaAPI.EmojiPackController.remote",
	responses: %{
	200 => emoji_packs_response(),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def index_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Lists local custom emoji packs",
	operationId: "PleromaAPI.EmojiPackController.index",
	parameters: [
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 50},
	"Number of emoji packs to return"
	)
	],
	responses: %{
	200 => emoji_packs_response()
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Show emoji pack",
	operationId: "PleromaAPI.EmojiPackController.show",
	parameters: [
	name_param(),
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 30},
	"Number of emoji to return"
	)
	],
	responses: %{
	200 => Operation.response("Emoji Pack", "application/json", emoji_pack()),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def archive_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Requests a local pack archive from the instance",
	operationId: "PleromaAPI.EmojiPackController.archive",
	parameters: [name_param()],
	responses: %{
	200 =>
	Operation.response("Archive file", "application/octet-stream", %Schema{
	type: :string,
	format: :binary
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def download_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Download pack from another instance",
	operationId: "PleromaAPI.EmojiPackController.download",
	security: [%{"oAuth" => ["write"]}],
	requestBody: request_body("Parameters", download_request(), required: true),
	responses: %{
	200 => ok_response(),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp download_request do
	%Schema{
	type: :object,
	required: [:url, :name],
	properties: %{
	url: %Schema{
	type: :string,
	format: :uri,
	description: "URL of the instance to download from"
	},
	name: %Schema{type: :string, format: :uri, description: "Pack Name"},
	as: %Schema{type: :string, format: :uri, description: "Save as"}
	}
	}
	end

	def create_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Create an empty pack",
	operationId: "PleromaAPI.EmojiPackController.create",
	security: [%{"oAuth" => ["write"]}],
	parameters: [name_param()],
	responses: %{
	200 => ok_response(),
	400 => Operation.response("Not Found", "application/json", ApiError),
	409 => Operation.response("Conflict", "application/json", ApiError),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Delete a custom emoji pack",
	operationId: "PleromaAPI.EmojiPackController.delete",
	security: [%{"oAuth" => ["write"]}],
	parameters: [name_param()],
	responses: %{
	200 => ok_response(),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Updates (replaces) pack metadata",
	operationId: "PleromaAPI.EmojiPackController.update",
	security: [%{"oAuth" => ["write"]}],
	requestBody: request_body("Parameters", update_request(), required: true),
	parameters: [name_param()],
	responses: %{
	200 => Operation.response("Metadata", "application/json", metadata()),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	- def add_file_operation do
	- %Operation{
	- tags: ["Emoji Packs"],
	- summary: "Add new file to the pack",
	- operationId: "PleromaAPI.EmojiPackController.add_file",
	- security: [%{"oAuth" => ["write"]}],
	- requestBody: request_body("Parameters", add_file_request(), required: true),
	- parameters: [name_param()],
	- responses: %{
	- 200 => Operation.response("Files Object", "application/json", files_object()),
	- 400 => Operation.response("Bad Request", "application/json", ApiError),
	- 409 => Operation.response("Conflict", "application/json", ApiError)
	- }
	- }
	- end
	-
	- defp add_file_request do
	- %Schema{
	- type: :object,
	- required: [:file],
	- properties: %{
	- file: %Schema{
	- description:
	- "File needs to be uploaded with the multipart request or link to remote file",
	- anyOf: [
	- %Schema{type: :string, format: :binary},
	- %Schema{type: :string, format: :uri}
	- ]
	- },
	- shortcode: %Schema{
	- type: :string,
	- description:
	- "Shortcode for new emoji, must be unique for all emoji. If not sended, shortcode will be taken from original filename."
	- },
	- filename: %Schema{
	- type: :string,
	- description:
	- "New emoji file name. If not specified will be taken from original filename."
	- }
	- }
	- }
	- end
	-
	- def update_file_operation do
	- %Operation{
	- tags: ["Emoji Packs"],
	- summary: "Add new file to the pack",
	- operationId: "PleromaAPI.EmojiPackController.update_file",
	- security: [%{"oAuth" => ["write"]}],
	- requestBody: request_body("Parameters", update_file_request(), required: true),
	- parameters: [name_param()],
	- responses: %{
	- 200 => Operation.response("Files Object", "application/json", files_object()),
	- 400 => Operation.response("Bad Request", "application/json", ApiError),
	- 409 => Operation.response("Conflict", "application/json", ApiError)
	- }
	- }
	- end
	-
	- defp update_file_request do
	- %Schema{
	- type: :object,
	- required: [:shortcode, :new_shortcode, :new_filename],
	- properties: %{
	- shortcode: %Schema{
	- type: :string,
	- description: "Emoji file shortcode"
	- },
	- new_shortcode: %Schema{
	- type: :string,
	- description: "New emoji file shortcode"
	- },
	- new_filename: %Schema{
	- type: :string,
	- description: "New filename for emoji file"
	- },
	- force: %Schema{
	- type: :boolean,
	- description: "With true value to overwrite existing emoji with new shortcode",
	- default: false
	- }
	- }
	- }
	- end
	-
	- def delete_file_operation do
	- %Operation{
	- tags: ["Emoji Packs"],
	- summary: "Delete emoji file from pack",
	- operationId: "PleromaAPI.EmojiPackController.delete_file",
	- security: [%{"oAuth" => ["write"]}],
	- parameters: [
	- name_param(),
	- Operation.parameter(:shortcode, :query, :string, "File shortcode",
	- example: "cofe",
	- required: true
	- )
	- ],
	- responses: %{
	- 200 => Operation.response("Files Object", "application/json", files_object()),
	- 400 => Operation.response("Bad Request", "application/json", ApiError)
	- }
	- }
	- end
	-
	def import_from_filesystem_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Imports packs from filesystem",
	operationId: "PleromaAPI.EmojiPackController.import",
	security: [%{"oAuth" => ["write"]}],
	responses: %{
	200 =>
	Operation.response("Array of imported pack names", "application/json", %Schema{
	type: :array,
	items: %Schema{type: :string}
	})
	}
	}
	end

	defp name_param do
	Operation.parameter(:name, :path, :string, "Pack Name", example: "cofe", required: true)
	end

	defp url_param do
	Operation.parameter(
	:url,
	:query,
	%Schema{type: :string, format: :uri},
	"URL of the instance",
	required: true
	)
	end

	defp ok_response do
	Operation.response("Ok", "application/json", %Schema{type: :string, example: "ok"})
	end

	defp emoji_packs_response do
	Operation.response(
	"Object with pack names as keys and pack contents as values",
	"application/json",
	%Schema{
	type: :object,
	additionalProperties: emoji_pack(),
	example: %{
	"emojos" => emoji_pack().example
	}
	}
	)
	end

	defp emoji_pack do
	%Schema{
	title: "EmojiPack",
	type: :object,
	properties: %{
	files: files_object(),
	pack: %Schema{
	type: :object,
	properties: %{
	license: %Schema{type: :string},
	homepage: %Schema{type: :string, format: :uri},
	description: %Schema{type: :string},
	"can-download": %Schema{type: :boolean},
	"share-files": %Schema{type: :boolean},
	"download-sha256": %Schema{type: :string}
	}
	}
	},
	example: %{
	"files" => %{"emacs" => "emacs.png", "guix" => "guix.png"},
	"pack" => %{
	"license" => "Test license",
	"homepage" => "https://pleroma.social",
	"description" => "Test description",
	"can-download" => true,
	"share-files" => true,
	"download-sha256" => "57482F30674FD3DE821FF48C81C00DA4D4AF1F300209253684ABA7075E5FC238"
	}
	}
	}
	end

	defp files_object do
	%Schema{
	type: :object,
	additionalProperties: %Schema{type: :string},
	description: "Object with emoji names as keys and filenames as values"
	}
	end

	defp update_request do
	%Schema{
	type: :object,
	properties: %{
	metadata: %Schema{
	type: :object,
	description: "Metadata to replace the old one",
	properties: %{
	license: %Schema{type: :string},
	homepage: %Schema{type: :string, format: :uri},
	description: %Schema{type: :string},
	"fallback-src": %Schema{
	type: :string,
	format: :uri,
	description: "Fallback url to download pack from"
	},
	"fallback-src-sha256": %Schema{
	type: :string,
	description: "SHA256 encoded for fallback pack archive"
	},
	"share-files": %Schema{type: :boolean, description: "Is pack allowed for sharing?"}
	}
	}
	}
	}
	end

	defp metadata do
	%Schema{
	type: :object,
	properties: %{
	license: %Schema{type: :string},
	homepage: %Schema{type: :string, format: :uri},
	description: %Schema{type: :string},
	"fallback-src": %Schema{
	type: :string,
	format: :uri,
	description: "Fallback url to download pack from"
	},
	"fallback-src-sha256": %Schema{
	type: :string,
	description: "SHA256 encoded for fallback pack archive"
	},
	"share-files": %Schema{type: :boolean, description: "Is pack allowed for sharing?"}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/emoji_file_controller.ex b/lib/pleroma/web/pleroma_api/controllers/emoji_file_controller.ex
	new file mode 100644
	index 000000000..ba9f07795
	--- /dev/null
	+++ b/lib/pleroma/web/pleroma_api/controllers/emoji_file_controller.ex
	@@ -0,0 +1,122 @@
	+defmodule Pleroma.Web.PleromaAPI.EmojiFileController do
	+ use Pleroma.Web, :controller
	+
	+ alias Pleroma.Emoji.Pack
	+ alias Pleroma.Web.ApiSpec
	+
	+ plug(Pleroma.Web.ApiSpec.CastAndValidate)
	+
	+ plug(
	+ Pleroma.Plugs.OAuthScopesPlug,
	+ %{scopes: ["write"], admin: true}
	+ when action in [
	+ :create,
	+ :update,
	+ :delete
	+ ]
	+ )
	+
	+ defdelegate open_api_operation(action), to: ApiSpec.PleromaEmojiFileOperation
	+
	+ def create(%{body_params: params} = conn, %{name: pack_name}) do
	+ filename = params[:filename] \|\| get_filename(params[:file])
	+ shortcode = params[:shortcode] \|\| Path.basename(filename, Path.extname(filename))
	+
	+ with {:ok, pack} <- Pack.add_file(pack_name, shortcode, filename, params[:file]) do
	+ json(conn, pack.files)
	+ else
	+ {:error, :already_exists} ->
	+ conn
	+ \|> put_status(:conflict)
	+ \|> json(%{error: "An emoji with the \"#{shortcode}\" shortcode already exists"})
	+
	+ {:error, :not_found} ->
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{error: "pack \"#{pack_name}\" is not found"})
	+
	+ {:error, :empty_values} ->
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{error: "pack name, shortcode or filename cannot be empty"})
	+
	+ {:error, _} ->
	+ render_error(
	+ conn,
	+ :internal_server_error,
	+ "Unexpected error occurred while adding file to pack."
	+ )
	+ end
	+ end
	+
	+ def update(%{body_params: %{shortcode: shortcode} = params} = conn, %{name: pack_name}) do
	+ new_shortcode = params[:new_shortcode]
	+ new_filename = params[:new_filename]
	+ force = params[:force]
	+
	+ with {:ok, pack} <- Pack.update_file(pack_name, shortcode, new_shortcode, new_filename, force) do
	+ json(conn, pack.files)
	+ else
	+ {:error, :doesnt_exist} ->
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{error: "Emoji \"#{shortcode}\" does not exist"})
	+
	+ {:error, :already_exists} ->
	+ conn
	+ \|> put_status(:conflict)
	+ \|> json(%{
	+ error:
	+ "New shortcode \"#{new_shortcode}\" is already used. If you want to override emoji use 'force' option"
	+ })
	+
	+ {:error, :not_found} ->
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{error: "pack \"#{pack_name}\" is not found"})
	+
	+ {:error, :empty_values} ->
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{error: "new_shortcode or new_filename cannot be empty"})
	+
	+ {:error, _} ->
	+ render_error(
	+ conn,
	+ :internal_server_error,
	+ "Unexpected error occurred while updating file in pack."
	+ )
	+ end
	+ end
	+
	+ def delete(conn, %{name: pack_name, shortcode: shortcode}) do
	+ with {:ok, pack} <- Pack.delete_file(pack_name, shortcode) do
	+ json(conn, pack.files)
	+ else
	+ {:error, :doesnt_exist} ->
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{error: "Emoji \"#{shortcode}\" does not exist"})
	+
	+ {:error, :not_found} ->
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{error: "pack \"#{pack_name}\" is not found"})
	+
	+ {:error, :empty_values} ->
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{error: "pack name or shortcode cannot be empty"})
	+
	+ {:error, _} ->
	+ render_error(
	+ conn,
	+ :internal_server_error,
	+ "Unexpected error occurred while removing file from pack."
	+ )
	+ end
	+ end
	+
	+ defp get_filename(%Plug.Upload{filename: filename}), do: filename
	+ defp get_filename(url) when is_binary(url), do: Path.basename(url)
	+end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex b/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex
	index 657f46324..e3969fee1 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex
	@@ -1,304 +1,199 @@
	defmodule Pleroma.Web.PleromaAPI.EmojiPackController do
	use Pleroma.Web, :controller

	alias Pleroma.Emoji.Pack

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	Pleroma.Plugs.OAuthScopesPlug,
	%{scopes: ["write"], admin: true}
	when action in [
	:import_from_filesystem,
	:remote,
	:download,
	:create,
	:update,
	- :delete,
	- :add_file,
	- :update_file,
	- :delete_file
	+ :delete
	]
	)

	@skip_plugs [Pleroma.Plugs.OAuthScopesPlug, Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug]
	plug(:skip_plug, @skip_plugs when action in [:index, :show, :archive])

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

	def remote(conn, %{url: url}) do
	with {:ok, packs} <- Pack.list_remote(url) do
	json(conn, packs)
	else
	{:error, :not_shareable} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "The requested instance does not support sharing emoji packs"})
	end
	end

	def index(conn, params) do
	emoji_path =
	[:instance, :static_dir]
	\|> Pleroma.Config.get!()
	\|> Path.join("emoji")

	with {:ok, packs, count} <- Pack.list_local(page: params.page, page_size: params.page_size) do
	json(conn, %{packs: packs, count: count})
	else
	{:error, :create_dir, e} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Failed to create the emoji pack directory at #{emoji_path}: #{e}"})

	{:error, :ls, e} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{
	error: "Failed to get the contents of the emoji pack directory at #{emoji_path}: #{e}"
	})
	end
	end

	def show(conn, %{name: name, page: page, page_size: page_size}) do
	name = String.trim(name)

	with {:ok, pack} <- Pack.show(name: name, page: page, page_size: page_size) do
	json(conn, pack)
	else
	{:error, :not_found} ->
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "Pack #{name} does not exist"})

	{:error, :empty_values} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "pack name cannot be empty"})
	end
	end

	def archive(conn, %{name: name}) do
	with {:ok, archive} <- Pack.get_archive(name) do
	send_download(conn, {:binary, archive}, filename: "#{name}.zip")
	else
	{:error, :cant_download} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{
	error:
	"Pack #{name} cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
	})

	{:error, :not_found} ->
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "Pack #{name} does not exist"})
	end
	end

	def download(%{body_params: %{url: url, name: name} = params} = conn, _) do
	with {:ok, _pack} <- Pack.download(name, url, params[:as]) do
	json(conn, "ok")
	else
	{:error, :not_shareable} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "The requested instance does not support sharing emoji packs"})

	{:error, :invalid_checksum} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "SHA256 for the pack doesn't match the one sent by the server"})

	{:error, e} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: e})
	end
	end

	def create(conn, %{name: name}) do
	name = String.trim(name)

	with {:ok, _pack} <- Pack.create(name) do
	json(conn, "ok")
	else
	{:error, :eexist} ->
	conn
	\|> put_status(:conflict)
	\|> json(%{error: "A pack named \"#{name}\" already exists"})

	{:error, :empty_values} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "pack name cannot be empty"})

	{:error, _} ->
	render_error(
	conn,
	:internal_server_error,
	"Unexpected error occurred while creating pack."
	)
	end
	end

	def delete(conn, %{name: name}) do
	name = String.trim(name)

	with {:ok, deleted} when deleted != [] <- Pack.delete(name) do
	json(conn, "ok")
	else
	{:ok, []} ->
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "Pack #{name} does not exist"})

	{:error, :empty_values} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "pack name cannot be empty"})

	{:error, _, _} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Couldn't delete the pack #{name}"})
	end
	end

	def update(%{body_params: %{metadata: metadata}} = conn, %{name: name}) do
	with {:ok, pack} <- Pack.update_metadata(name, metadata) do
	json(conn, pack.pack)
	else
	{:error, :incomplete} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "The fallback archive does not have all files specified in pack.json"})

	{:error, _} ->
	render_error(
	conn,
	:internal_server_error,
	"Unexpected error occurred while updating pack metadata."
	)
	end
	end

	- def add_file(%{body_params: params} = conn, %{name: name}) do
	- filename = params[:filename] \|\| get_filename(params[:file])
	- shortcode = params[:shortcode] \|\| Path.basename(filename, Path.extname(filename))
	-
	- with {:ok, pack} <- Pack.add_file(name, shortcode, filename, params[:file]) do
	- json(conn, pack.files)
	- else
	- {:error, :already_exists} ->
	- conn
	- \|> put_status(:conflict)
	- \|> json(%{error: "An emoji with the \"#{shortcode}\" shortcode already exists"})
	-
	- {:error, :not_found} ->
	- conn
	- \|> put_status(:bad_request)
	- \|> json(%{error: "pack \"#{name}\" is not found"})
	-
	- {:error, :empty_values} ->
	- conn
	- \|> put_status(:bad_request)
	- \|> json(%{error: "pack name, shortcode or filename cannot be empty"})
	-
	- {:error, _} ->
	- render_error(
	- conn,
	- :internal_server_error,
	- "Unexpected error occurred while adding file to pack."
	- )
	- end
	- end
	-
	- def update_file(%{body_params: %{shortcode: shortcode} = params} = conn, %{name: name}) do
	- new_shortcode = params[:new_shortcode]
	- new_filename = params[:new_filename]
	- force = params[:force]
	-
	- with {:ok, pack} <- Pack.update_file(name, shortcode, new_shortcode, new_filename, force) do
	- json(conn, pack.files)
	- else
	- {:error, :doesnt_exist} ->
	- conn
	- \|> put_status(:bad_request)
	- \|> json(%{error: "Emoji \"#{shortcode}\" does not exist"})
	-
	- {:error, :already_exists} ->
	- conn
	- \|> put_status(:conflict)
	- \|> json(%{
	- error:
	- "New shortcode \"#{new_shortcode}\" is already used. If you want to override emoji use 'force' option"
	- })
	-
	- {:error, :not_found} ->
	- conn
	- \|> put_status(:bad_request)
	- \|> json(%{error: "pack \"#{name}\" is not found"})
	-
	- {:error, :empty_values} ->
	- conn
	- \|> put_status(:bad_request)
	- \|> json(%{error: "new_shortcode or new_filename cannot be empty"})
	-
	- {:error, _} ->
	- render_error(
	- conn,
	- :internal_server_error,
	- "Unexpected error occurred while updating file in pack."
	- )
	- end
	- end
	-
	- def delete_file(conn, %{name: name, shortcode: shortcode}) do
	- with {:ok, pack} <- Pack.delete_file(name, shortcode) do
	- json(conn, pack.files)
	- else
	- {:error, :doesnt_exist} ->
	- conn
	- \|> put_status(:bad_request)
	- \|> json(%{error: "Emoji \"#{shortcode}\" does not exist"})
	-
	- {:error, :not_found} ->
	- conn
	- \|> put_status(:bad_request)
	- \|> json(%{error: "pack \"#{name}\" is not found"})
	-
	- {:error, :empty_values} ->
	- conn
	- \|> put_status(:bad_request)
	- \|> json(%{error: "pack name or shortcode cannot be empty"})
	-
	- {:error, _} ->
	- render_error(
	- conn,
	- :internal_server_error,
	- "Unexpected error occurred while removing file from pack."
	- )
	- end
	- end
	-
	def import_from_filesystem(conn, _params) do
	with {:ok, names} <- Pack.import_from_filesystem() do
	json(conn, names)
	else
	{:error, :no_read_write} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Error: emoji pack directory must be writable"})

	{:error, _} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Error accessing emoji pack directory"})
	end
	end
	-
	- defp get_filename(%Plug.Upload{filename: filename}), do: filename
	- defp get_filename(url) when is_binary(url), do: Path.basename(url)
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index c6433cc53..8a307d591 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,726 +1,726 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router

	pipeline :browser do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	end

	pipeline :oauth do
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	end

	pipeline :expect_authentication do
	plug(Pleroma.Plugs.ExpectAuthenticatedCheckPlug)
	end

	pipeline :expect_public_instance_or_authentication do
	plug(Pleroma.Plugs.ExpectPublicOrAuthenticatedCheckPlug)
	end

	pipeline :authenticate do
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	end

	pipeline :after_auth do
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :base_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(:authenticate)
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :api do
	plug(:expect_public_instance_or_authentication)
	plug(:base_api)
	plug(:after_auth)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :authenticated_api do
	plug(:expect_authentication)
	plug(:base_api)
	plug(:after_auth)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :admin_api do
	plug(:expect_authentication)
	plug(:base_api)
	plug(Pleroma.Plugs.AdminSecretAuthenticationPlug)
	plug(:after_auth)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.UserIsAdminPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :mastodon_html do
	plug(:browser)
	plug(:authenticate)
	plug(:after_auth)
	end

	pipeline :pleroma_html do
	plug(:browser)
	plug(:authenticate)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :well_known do
	plug(:accepts, ["json", "jrd+json", "xml", "xrd+xml"])
	end

	pipeline :config do
	plug(:accepts, ["json", "xml"])
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :pleroma_api do
	plug(:accepts, ["html", "json"])
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :mailbox_preview do
	plug(:accepts, ["html"])

	plug(:put_secure_browser_headers, %{
	"content-security-policy" =>
	"default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline' 'unsafe-eval'"
	})
	end

	pipeline :http_signature do
	plug(Pleroma.Web.Plugs.HTTPSignaturePlug)
	plug(Pleroma.Web.Plugs.MappedSignatureToIdentityPlug)
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_api)

	get("/password_reset/:token", PasswordController, :reset, as: :reset_password)
	post("/password_reset", PasswordController, :do_reset, as: :reset_password)
	get("/emoji", UtilController, :emoji)
	get("/captcha", UtilController, :captcha)
	get("/healthcheck", UtilController, :healthcheck)
	end

	scope "/api/pleroma", Pleroma.Web do
	pipe_through(:pleroma_api)
	post("/uploader_callback/:upload_path", UploaderController, :callback)
	end

	scope "/api/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:admin_api)

	post("/users/follow", AdminAPIController, :user_follow)
	post("/users/unfollow", AdminAPIController, :user_unfollow)

	put("/users/disable_mfa", AdminAPIController, :disable_mfa)
	delete("/users", AdminAPIController, :user_delete)
	post("/users", AdminAPIController, :users_create)
	patch("/users/:nickname/toggle_activation", AdminAPIController, :user_toggle_activation)
	patch("/users/activate", AdminAPIController, :user_activate)
	patch("/users/deactivate", AdminAPIController, :user_deactivate)
	patch("/users/approve", AdminAPIController, :user_approve)
	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)

	get("/users/:nickname/permission_group", AdminAPIController, :right_get)
	get("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_get)

	post("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_add)

	delete(
	"/users/:nickname/permission_group/:permission_group",
	AdminAPIController,
	:right_delete
	)

	post("/users/permission_group/:permission_group", AdminAPIController, :right_add_multiple)

	delete(
	"/users/permission_group/:permission_group",
	AdminAPIController,
	:right_delete_multiple
	)

	get("/relay", RelayController, :index)
	post("/relay", RelayController, :follow)
	delete("/relay", RelayController, :unfollow)

	post("/users/invite_token", InviteController, :create)
	get("/users/invites", InviteController, :index)
	post("/users/revoke_invite", InviteController, :revoke)
	post("/users/email_invite", InviteController, :email)

	get("/users/:nickname/password_reset", AdminAPIController, :get_password_reset)
	patch("/users/force_password_reset", AdminAPIController, :force_password_reset)
	get("/users/:nickname/credentials", AdminAPIController, :show_user_credentials)
	patch("/users/:nickname/credentials", AdminAPIController, :update_user_credentials)

	get("/users", AdminAPIController, :list_users)
	get("/users/:nickname", AdminAPIController, :user_show)
	get("/users/:nickname/statuses", AdminAPIController, :list_user_statuses)

	get("/instances/:instance/statuses", AdminAPIController, :list_instance_statuses)

	patch("/users/confirm_email", AdminAPIController, :confirm_email)
	patch("/users/resend_confirmation_email", AdminAPIController, :resend_confirmation_email)

	get("/reports", ReportController, :index)
	get("/reports/:id", ReportController, :show)
	patch("/reports", ReportController, :update)
	post("/reports/:id/notes", ReportController, :notes_create)
	delete("/reports/:report_id/notes/:id", ReportController, :notes_delete)

	get("/statuses/:id", StatusController, :show)
	put("/statuses/:id", StatusController, :update)
	delete("/statuses/:id", StatusController, :delete)
	get("/statuses", StatusController, :index)

	get("/config", ConfigController, :show)
	post("/config", ConfigController, :update)
	get("/config/descriptions", ConfigController, :descriptions)
	get("/need_reboot", AdminAPIController, :need_reboot)
	get("/restart", AdminAPIController, :restart)

	get("/moderation_log", AdminAPIController, :list_log)

	post("/reload_emoji", AdminAPIController, :reload_emoji)
	get("/stats", AdminAPIController, :stats)

	get("/oauth_app", OAuthAppController, :index)
	post("/oauth_app", OAuthAppController, :create)
	patch("/oauth_app/:id", OAuthAppController, :update)
	delete("/oauth_app/:id", OAuthAppController, :delete)

	get("/media_proxy_caches", MediaProxyCacheController, :index)
	post("/media_proxy_caches/delete", MediaProxyCacheController, :delete)
	post("/media_proxy_caches/purge", MediaProxyCacheController, :purge)
	end

	scope "/api/pleroma/emoji", Pleroma.Web.PleromaAPI do
	# Modifying packs
	scope "/packs" do
	pipe_through(:admin_api)

	get("/import", EmojiPackController, :import_from_filesystem)
	get("/remote", EmojiPackController, :remote)
	post("/download", EmojiPackController, :download)

	post("/:name", EmojiPackController, :create)
	patch("/:name", EmojiPackController, :update)
	delete("/:name", EmojiPackController, :delete)

	- post("/:name/files", EmojiPackController, :add_file)
	- patch("/:name/files", EmojiPackController, :update_file)
	- delete("/:name/files", EmojiPackController, :delete_file)
	+ post("/:name/files", EmojiFileController, :create)
	+ patch("/:name/files", EmojiFileController, :update)
	+ delete("/:name/files", EmojiFileController, :delete)
	end

	# Pack info / downloading
	scope "/packs" do
	pipe_through(:api)
	get("/", EmojiPackController, :index)
	get("/:name", EmojiPackController, :show)
	get("/:name/archive", EmojiPackController, :archive)
	end
	end

	scope "/", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_html)

	post("/main/ostatus", UtilController, :remote_subscribe)
	get("/ostatus_subscribe", RemoteFollowController, :follow)

	post("/ostatus_subscribe", RemoteFollowController, :do_follow)
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:authenticated_api)

	post("/change_email", UtilController, :change_email)
	post("/change_password", UtilController, :change_password)
	post("/delete_account", UtilController, :delete_account)
	put("/notification_settings", UtilController, :update_notificaton_settings)
	post("/disable_account", UtilController, :disable_account)

	post("/blocks_import", UtilController, :blocks_import)
	post("/follow_import", UtilController, :follow_import)
	end

	scope "/api/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:authenticated_api)

	get("/accounts/mfa", TwoFactorAuthenticationController, :settings)
	get("/accounts/mfa/backup_codes", TwoFactorAuthenticationController, :backup_codes)
	get("/accounts/mfa/setup/:method", TwoFactorAuthenticationController, :setup)
	post("/accounts/mfa/confirm/:method", TwoFactorAuthenticationController, :confirm)
	delete("/accounts/mfa/:method", TwoFactorAuthenticationController, :disable)
	end

	scope "/oauth", Pleroma.Web.OAuth do
	scope [] do
	pipe_through(:oauth)
	get("/authorize", OAuthController, :authorize)
	end

	post("/authorize", OAuthController, :create_authorization)
	post("/token", OAuthController, :token_exchange)
	post("/revoke", OAuthController, :token_revoke)
	get("/registration_details", OAuthController, :registration_details)

	post("/mfa/challenge", MFAController, :challenge)
	post("/mfa/verify", MFAController, :verify, as: :mfa_verify)
	get("/mfa", MFAController, :show)

	scope [] do
	pipe_through(:browser)

	get("/prepare_request", OAuthController, :prepare_request)
	get("/:provider", OAuthController, :request)
	get("/:provider/callback", OAuthController, :callback)
	post("/register", OAuthController, :register)
	end
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:api)

	get("/statuses/:id/reactions/:emoji", EmojiReactionController, :index)
	get("/statuses/:id/reactions", EmojiReactionController, :index)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	scope [] do
	pipe_through(:authenticated_api)

	post("/chats/by-account-id/:id", ChatController, :create)
	get("/chats", ChatController, :index)
	get("/chats/:id", ChatController, :show)
	get("/chats/:id/messages", ChatController, :messages)
	post("/chats/:id/messages", ChatController, :post_chat_message)
	delete("/chats/:id/messages/:message_id", ChatController, :delete_message)
	post("/chats/:id/read", ChatController, :mark_as_read)
	post("/chats/:id/messages/:message_id/read", ChatController, :mark_message_as_read)

	get("/conversations/:id/statuses", ConversationController, :statuses)
	get("/conversations/:id", ConversationController, :show)
	post("/conversations/read", ConversationController, :mark_as_read)
	patch("/conversations/:id", ConversationController, :update)

	put("/statuses/:id/reactions/:emoji", EmojiReactionController, :create)
	delete("/statuses/:id/reactions/:emoji", EmojiReactionController, :delete)
	post("/notifications/read", NotificationController, :mark_as_read)

	get("/mascot", MascotController, :show)
	put("/mascot", MascotController, :update)

	post("/scrobble", ScrobbleController, :create)
	end

	scope [] do
	pipe_through(:api)
	get("/accounts/:id/favourites", AccountController, :favourites)
	end

	scope [] do
	pipe_through(:authenticated_api)

	post("/accounts/:id/subscribe", AccountController, :subscribe)
	post("/accounts/:id/unsubscribe", AccountController, :unsubscribe)
	end

	post("/accounts/confirmation_resend", AccountController, :confirmation_resend)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:api)
	get("/accounts/:id/scrobbles", ScrobbleController, :index)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:authenticated_api)

	get("/accounts/verify_credentials", AccountController, :verify_credentials)
	patch("/accounts/update_credentials", AccountController, :update_credentials)

	get("/accounts/relationships", AccountController, :relationships)
	get("/accounts/:id/lists", AccountController, :lists)
	get("/accounts/:id/identity_proofs", AccountController, :identity_proofs)
	get("/endorsements", AccountController, :endorsements)
	get("/blocks", AccountController, :blocks)
	get("/mutes", AccountController, :mutes)

	post("/follows", AccountController, :follow_by_uri)
	post("/accounts/:id/follow", AccountController, :follow)
	post("/accounts/:id/unfollow", AccountController, :unfollow)
	post("/accounts/:id/block", AccountController, :block)
	post("/accounts/:id/unblock", AccountController, :unblock)
	post("/accounts/:id/mute", AccountController, :mute)
	post("/accounts/:id/unmute", AccountController, :unmute)

	get("/apps/verify_credentials", AppController, :verify_credentials)

	get("/conversations", ConversationController, :index)
	post("/conversations/:id/read", ConversationController, :mark_as_read)

	get("/domain_blocks", DomainBlockController, :index)
	post("/domain_blocks", DomainBlockController, :create)
	delete("/domain_blocks", DomainBlockController, :delete)

	get("/filters", FilterController, :index)

	post("/filters", FilterController, :create)
	get("/filters/:id", FilterController, :show)
	put("/filters/:id", FilterController, :update)
	delete("/filters/:id", FilterController, :delete)

	get("/follow_requests", FollowRequestController, :index)
	post("/follow_requests/:id/authorize", FollowRequestController, :authorize)
	post("/follow_requests/:id/reject", FollowRequestController, :reject)

	get("/lists", ListController, :index)
	get("/lists/:id", ListController, :show)
	get("/lists/:id/accounts", ListController, :list_accounts)

	delete("/lists/:id", ListController, :delete)
	post("/lists", ListController, :create)
	put("/lists/:id", ListController, :update)
	post("/lists/:id/accounts", ListController, :add_to_list)
	delete("/lists/:id/accounts", ListController, :remove_from_list)

	get("/markers", MarkerController, :index)
	post("/markers", MarkerController, :upsert)

	post("/media", MediaController, :create)
	get("/media/:id", MediaController, :show)
	put("/media/:id", MediaController, :update)

	get("/notifications", NotificationController, :index)
	get("/notifications/:id", NotificationController, :show)

	post("/notifications/:id/dismiss", NotificationController, :dismiss)
	post("/notifications/clear", NotificationController, :clear)
	delete("/notifications/destroy_multiple", NotificationController, :destroy_multiple)
	# Deprecated: was removed in Mastodon v3, use `/notifications/:id/dismiss` instead
	post("/notifications/dismiss", NotificationController, :dismiss_via_body)

	post("/polls/:id/votes", PollController, :vote)

	post("/reports", ReportController, :create)

	get("/scheduled_statuses", ScheduledActivityController, :index)
	get("/scheduled_statuses/:id", ScheduledActivityController, :show)

	put("/scheduled_statuses/:id", ScheduledActivityController, :update)
	delete("/scheduled_statuses/:id", ScheduledActivityController, :delete)

	# Unlike `GET /api/v1/accounts/:id/favourites`, demands authentication
	get("/favourites", StatusController, :favourites)
	get("/bookmarks", StatusController, :bookmarks)

	post("/statuses", StatusController, :create)
	delete("/statuses/:id", StatusController, :delete)
	post("/statuses/:id/reblog", StatusController, :reblog)
	post("/statuses/:id/unreblog", StatusController, :unreblog)
	post("/statuses/:id/favourite", StatusController, :favourite)
	post("/statuses/:id/unfavourite", StatusController, :unfavourite)
	post("/statuses/:id/pin", StatusController, :pin)
	post("/statuses/:id/unpin", StatusController, :unpin)
	post("/statuses/:id/bookmark", StatusController, :bookmark)
	post("/statuses/:id/unbookmark", StatusController, :unbookmark)
	post("/statuses/:id/mute", StatusController, :mute_conversation)
	post("/statuses/:id/unmute", StatusController, :unmute_conversation)

	post("/push/subscription", SubscriptionController, :create)
	get("/push/subscription", SubscriptionController, :show)
	put("/push/subscription", SubscriptionController, :update)
	delete("/push/subscription", SubscriptionController, :delete)

	get("/suggestions", SuggestionController, :index)

	get("/timelines/home", TimelineController, :home)
	get("/timelines/direct", TimelineController, :direct)
	get("/timelines/list/:list_id", TimelineController, :list)
	end

	scope "/api/web", Pleroma.Web do
	pipe_through(:authenticated_api)

	# Backend-obscure settings blob for MastoFE, don't parse/reuse elsewhere
	put("/settings", MastoFEController, :put_settings)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:api)

	get("/accounts/search", SearchController, :account_search)
	get("/search", SearchController, :search)

	get("/accounts/:id/statuses", AccountController, :statuses)
	get("/accounts/:id/followers", AccountController, :followers)
	get("/accounts/:id/following", AccountController, :following)
	get("/accounts/:id", AccountController, :show)

	post("/accounts", AccountController, :create)

	get("/instance", InstanceController, :show)
	get("/instance/peers", InstanceController, :peers)

	post("/apps", AppController, :create)

	get("/statuses", StatusController, :index)
	get("/statuses/:id", StatusController, :show)
	get("/statuses/:id/context", StatusController, :context)
	get("/statuses/:id/card", StatusController, :card)
	get("/statuses/:id/favourited_by", StatusController, :favourited_by)
	get("/statuses/:id/reblogged_by", StatusController, :reblogged_by)

	get("/custom_emojis", CustomEmojiController, :index)

	get("/trends", MastodonAPIController, :empty_array)

	get("/timelines/public", TimelineController, :public)
	get("/timelines/tag/:tag", TimelineController, :hashtag)

	get("/polls/:id", PollController, :show)
	end

	scope "/api/v2", Pleroma.Web.MastodonAPI do
	pipe_through(:api)
	get("/search", SearchController, :search2)

	post("/media", MediaController, :create2)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:config)

	get("/pleroma/frontend_configurations", TwitterAPI.UtilController, :frontend_configurations)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:api)

	get(
	"/account/confirm_email/:user_id/:token",
	TwitterAPI.Controller,
	:confirm_email,
	as: :confirm_email
	)
	end

	scope "/api" do
	pipe_through(:base_api)

	get("/openapi", OpenApiSpex.Plug.RenderSpec, [])
	end

	scope "/api", Pleroma.Web, as: :authenticated_twitter_api do
	pipe_through(:authenticated_api)

	get("/oauth_tokens", TwitterAPI.Controller, :oauth_tokens)
	delete("/oauth_tokens/:id", TwitterAPI.Controller, :revoke_token)

	post(
	"/qvitter/statuses/notifications/read",
	TwitterAPI.Controller,
	:mark_notifications_as_read
	)
	end

	pipeline :ostatus do
	plug(:accepts, ["html", "xml", "rss", "atom", "activity+json", "json"])
	plug(Pleroma.Plugs.StaticFEPlug)
	end

	pipeline :oembed do
	plug(:accepts, ["json", "xml"])
	end

	scope "/", Pleroma.Web do
	pipe_through([:ostatus, :http_signature])

	get("/objects/:uuid", OStatus.OStatusController, :object)
	get("/activities/:uuid", OStatus.OStatusController, :activity)
	get("/notice/:id", OStatus.OStatusController, :notice)
	get("/notice/:id/embed_player", OStatus.OStatusController, :notice_player)

	# Mastodon compatibility routes
	get("/users/:nickname/statuses/:id", OStatus.OStatusController, :object)
	get("/users/:nickname/statuses/:id/activity", OStatus.OStatusController, :activity)

	get("/users/:nickname/feed", Feed.UserController, :feed, as: :user_feed)
	get("/users/:nickname", Feed.UserController, :feed_redirect, as: :user_feed)

	get("/tags/:tag", Feed.TagController, :feed, as: :tag_feed)
	end

	scope "/", Pleroma.Web do
	pipe_through(:browser)
	get("/mailer/unsubscribe/:token", Mailer.SubscriptionController, :unsubscribe)
	end

	pipeline :ap_service_actor do
	plug(:accepts, ["activity+json", "json"])
	end

	# Server to Server (S2S) AP interactions
	pipeline :activitypub do
	plug(:ap_service_actor)
	plug(:http_signature)
	end

	# Client to Server (C2S) AP interactions
	pipeline :activitypub_client do
	plug(:ap_service_actor)
	plug(:fetch_session)
	plug(:authenticate)
	plug(:after_auth)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through([:activitypub_client])

	get("/api/ap/whoami", ActivityPubController, :whoami)
	get("/users/:nickname/inbox", ActivityPubController, :read_inbox)

	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	post("/users/:nickname/outbox", ActivityPubController, :update_outbox)
	post("/api/ap/upload_media", ActivityPubController, :upload_media)

	# The following two are S2S as well, see `ActivityPub.fetch_follow_information_for_user/1`:
	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through(:activitypub)
	post("/inbox", ActivityPubController, :inbox)
	post("/users/:nickname/inbox", ActivityPubController, :inbox)
	end

	scope "/relay", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :relay)

	scope [] do
	pipe_through(:http_signature)
	post("/inbox", ActivityPubController, :inbox)
	end

	get("/following", ActivityPubController, :relay_following)
	get("/followers", ActivityPubController, :relay_followers)
	end

	scope "/internal/fetch", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :internal_fetch)
	post("/inbox", ActivityPubController, :inbox)
	end

	scope "/.well-known", Pleroma.Web do
	pipe_through(:well_known)

	get("/host-meta", WebFinger.WebFingerController, :host_meta)
	get("/webfinger", WebFinger.WebFingerController, :webfinger)
	get("/nodeinfo", Nodeinfo.NodeinfoController, :schemas)
	end

	scope "/nodeinfo", Pleroma.Web do
	get("/:version", Nodeinfo.NodeinfoController, :nodeinfo)
	end

	scope "/", Pleroma.Web do
	pipe_through(:api)

	get("/web/manifest.json", MastoFEController, :manifest)
	end

	scope "/", Pleroma.Web do
	pipe_through(:mastodon_html)

	get("/web/login", MastodonAPI.AuthController, :login)
	delete("/auth/sign_out", MastodonAPI.AuthController, :logout)

	post("/auth/password", MastodonAPI.AuthController, :password_reset)

	get("/web/*path", MastoFEController, :index)

	get("/embed/:id", EmbedController, :show)
	end

	scope "/proxy/", Pleroma.Web.MediaProxy do
	get("/:sig/:url", MediaProxyController, :remote)
	get("/:sig/:url/:filename", MediaProxyController, :remote)
	end

	if Pleroma.Config.get(:env) == :dev do
	scope "/dev" do
	pipe_through([:mailbox_preview])

	forward("/mailbox", Plug.Swoosh.MailboxPreview, base_path: "/dev/mailbox")
	end
	end

	# Test-only routes needed to test action dispatching and plug chain execution
	if Pleroma.Config.get(:env) == :test do
	@test_actions [
	:do_oauth_check,
	:fallback_oauth_check,
	:skip_oauth_check,
	:fallback_oauth_skip_publicity_check,
	:skip_oauth_skip_publicity_check,
	:missing_oauth_check_definition
	]

	scope "/test/api", Pleroma.Tests do
	pipe_through(:api)

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end

	scope "/test/authenticated_api", Pleroma.Tests do
	pipe_through(:authenticated_api)

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end
	end

	scope "/", Pleroma.Web.MongooseIM do
	get("/user_exists", MongooseIMController, :user_exists)
	get("/check_password", MongooseIMController, :check_password)
	end

	scope "/", Fallback do
	get("/registration/:token", RedirectController, :registration_page)
	get("/:maybe_nickname_or_id", RedirectController, :redirector_with_meta)
	get("/api*path", RedirectController, :api_not_implemented)
	get("/*path", RedirectController, :redirector_with_preload)

	options("/*path", RedirectController, :empty)
	end
	end
	diff --git a/test/web/pleroma_api/controllers/emoji_file_controller_test.exs b/test/web/pleroma_api/controllers/emoji_file_controller_test.exs
	new file mode 100644
	index 000000000..56be130be
	--- /dev/null
	+++ b/test/web/pleroma_api/controllers/emoji_file_controller_test.exs
	@@ -0,0 +1,318 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.PleromaAPI.EmojiFileControllerTest do
	+ use Pleroma.Web.ConnCase
	+
	+ import Tesla.Mock
	+ import Pleroma.Factory
	+
	+ @emoji_path Path.join(
	+ Pleroma.Config.get!([:instance, :static_dir]),
	+ "emoji"
	+ )
	+ setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false)
	+
	+ setup do: clear_config([:instance, :public], true)
	+
	+ setup do
	+ admin = insert(:user, is_admin: true)
	+ token = insert(:oauth_admin_token, user: admin)
	+
	+ admin_conn =
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> assign(:token, token)
	+
	+ Pleroma.Emoji.reload()
	+ {:ok, %{admin_conn: admin_conn}}
	+ end
	+
	+ describe "POST/PATCH/DELETE /api/pleroma/emoji/packs/:name/files" do
	+ setup do
	+ pack_file = "#{@emoji_path}/test_pack/pack.json"
	+ original_content = File.read!(pack_file)
	+
	+ on_exit(fn ->
	+ File.write!(pack_file, original_content)
	+ end)
	+
	+ :ok
	+ end
	+
	+ test "create shortcode exists", %{admin_conn: admin_conn} do
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank",
	+ filename: "dir/blank.png",
	+ file: %Plug.Upload{
	+ filename: "blank.png",
	+ path: "#{@emoji_path}/test_pack/blank.png"
	+ }
	+ })
	+ \|> json_response_and_validate_schema(:conflict) == %{
	+ "error" => "An emoji with the \"blank\" shortcode already exists"
	+ }
	+ end
	+
	+ test "don't rewrite old emoji", %{admin_conn: admin_conn} do
	+ on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir/") end)
	+
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank3",
	+ filename: "dir/blank.png",
	+ file: %Plug.Upload{
	+ filename: "blank.png",
	+ path: "#{@emoji_path}/test_pack/blank.png"
	+ }
	+ })
	+ \|> json_response_and_validate_schema(200) == %{
	+ "blank" => "blank.png",
	+ "blank2" => "blank2.png",
	+ "blank3" => "dir/blank.png"
	+ }
	+
	+ assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
	+
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank",
	+ new_shortcode: "blank2",
	+ new_filename: "dir_2/blank_3.png"
	+ })
	+ \|> json_response_and_validate_schema(:conflict) == %{
	+ "error" =>
	+ "New shortcode \"blank2\" is already used. If you want to override emoji use 'force' option"
	+ }
	+ end
	+
	+ test "rewrite old emoji with force option", %{admin_conn: admin_conn} do
	+ on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir_2/") end)
	+
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank3",
	+ filename: "dir/blank.png",
	+ file: %Plug.Upload{
	+ filename: "blank.png",
	+ path: "#{@emoji_path}/test_pack/blank.png"
	+ }
	+ })
	+ \|> json_response_and_validate_schema(200) == %{
	+ "blank" => "blank.png",
	+ "blank2" => "blank2.png",
	+ "blank3" => "dir/blank.png"
	+ }
	+
	+ assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
	+
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank3",
	+ new_shortcode: "blank4",
	+ new_filename: "dir_2/blank_3.png",
	+ force: true
	+ })
	+ \|> json_response_and_validate_schema(200) == %{
	+ "blank" => "blank.png",
	+ "blank2" => "blank2.png",
	+ "blank4" => "dir_2/blank_3.png"
	+ }
	+
	+ assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
	+ end
	+
	+ test "with empty filename", %{admin_conn: admin_conn} do
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank2",
	+ filename: "",
	+ file: %Plug.Upload{
	+ filename: "blank.png",
	+ path: "#{@emoji_path}/test_pack/blank.png"
	+ }
	+ })
	+ \|> json_response_and_validate_schema(:bad_request) == %{
	+ "error" => "pack name, shortcode or filename cannot be empty"
	+ }
	+ end
	+
	+ test "add file with not loaded pack", %{admin_conn: admin_conn} do
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/emoji/packs/not_loaded/files", %{
	+ shortcode: "blank3",
	+ filename: "dir/blank.png",
	+ file: %Plug.Upload{
	+ filename: "blank.png",
	+ path: "#{@emoji_path}/test_pack/blank.png"
	+ }
	+ })
	+ \|> json_response_and_validate_schema(:bad_request) == %{
	+ "error" => "pack \"not_loaded\" is not found"
	+ }
	+ end
	+
	+ test "remove file with not loaded pack", %{admin_conn: admin_conn} do
	+ assert admin_conn
	+ \|> delete("/api/pleroma/emoji/packs/not_loaded/files?shortcode=blank3")
	+ \|> json_response_and_validate_schema(:bad_request) == %{
	+ "error" => "pack \"not_loaded\" is not found"
	+ }
	+ end
	+
	+ test "remove file with empty shortcode", %{admin_conn: admin_conn} do
	+ assert admin_conn
	+ \|> delete("/api/pleroma/emoji/packs/not_loaded/files?shortcode=")
	+ \|> json_response_and_validate_schema(:bad_request) == %{
	+ "error" => "pack name or shortcode cannot be empty"
	+ }
	+ end
	+
	+ test "update file with not loaded pack", %{admin_conn: admin_conn} do
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> patch("/api/pleroma/emoji/packs/not_loaded/files", %{
	+ shortcode: "blank4",
	+ new_shortcode: "blank3",
	+ new_filename: "dir_2/blank_3.png"
	+ })
	+ \|> json_response_and_validate_schema(:bad_request) == %{
	+ "error" => "pack \"not_loaded\" is not found"
	+ }
	+ end
	+
	+ test "new with shortcode as file with update", %{admin_conn: admin_conn} do
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank4",
	+ filename: "dir/blank.png",
	+ file: %Plug.Upload{
	+ filename: "blank.png",
	+ path: "#{@emoji_path}/test_pack/blank.png"
	+ }
	+ })
	+ \|> json_response_and_validate_schema(200) == %{
	+ "blank" => "blank.png",
	+ "blank4" => "dir/blank.png",
	+ "blank2" => "blank2.png"
	+ }
	+
	+ assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
	+
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank4",
	+ new_shortcode: "blank3",
	+ new_filename: "dir_2/blank_3.png"
	+ })
	+ \|> json_response_and_validate_schema(200) == %{
	+ "blank3" => "dir_2/blank_3.png",
	+ "blank" => "blank.png",
	+ "blank2" => "blank2.png"
	+ }
	+
	+ refute File.exists?("#{@emoji_path}/test_pack/dir/")
	+ assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
	+
	+ assert admin_conn
	+ \|> delete("/api/pleroma/emoji/packs/test_pack/files?shortcode=blank3")
	+ \|> json_response_and_validate_schema(200) == %{
	+ "blank" => "blank.png",
	+ "blank2" => "blank2.png"
	+ }
	+
	+ refute File.exists?("#{@emoji_path}/test_pack/dir_2/")
	+
	+ on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir") end)
	+ end
	+
	+ test "new with shortcode from url", %{admin_conn: admin_conn} do
	+ mock(fn
	+ %{
	+ method: :get,
	+ url: "https://test-blank/blank_url.png"
	+ } ->
	+ text(File.read!("#{@emoji_path}/test_pack/blank.png"))
	+ end)
	+
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank_url",
	+ file: "https://test-blank/blank_url.png"
	+ })
	+ \|> json_response_and_validate_schema(200) == %{
	+ "blank_url" => "blank_url.png",
	+ "blank" => "blank.png",
	+ "blank2" => "blank2.png"
	+ }
	+
	+ assert File.exists?("#{@emoji_path}/test_pack/blank_url.png")
	+
	+ on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/blank_url.png") end)
	+ end
	+
	+ test "new without shortcode", %{admin_conn: admin_conn} do
	+ on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/shortcode.png") end)
	+
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ file: %Plug.Upload{
	+ filename: "shortcode.png",
	+ path: "#{Pleroma.Config.get([:instance, :static_dir])}/add/shortcode.png"
	+ }
	+ })
	+ \|> json_response_and_validate_schema(200) == %{
	+ "shortcode" => "shortcode.png",
	+ "blank" => "blank.png",
	+ "blank2" => "blank2.png"
	+ }
	+ end
	+
	+ test "remove non existing shortcode in pack.json", %{admin_conn: admin_conn} do
	+ assert admin_conn
	+ \|> delete("/api/pleroma/emoji/packs/test_pack/files?shortcode=blank3")
	+ \|> json_response_and_validate_schema(:bad_request) == %{
	+ "error" => "Emoji \"blank3\" does not exist"
	+ }
	+ end
	+
	+ test "update non existing emoji", %{admin_conn: admin_conn} do
	+ assert admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank3",
	+ new_shortcode: "blank4",
	+ new_filename: "dir_2/blank_3.png"
	+ })
	+ \|> json_response_and_validate_schema(:bad_request) == %{
	+ "error" => "Emoji \"blank3\" does not exist"
	+ }
	+ end
	+
	+ test "update with empty shortcode", %{admin_conn: admin_conn} do
	+ assert %{
	+ "error" => "Missing field: new_shortcode."
	+ } =
	+ admin_conn
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	+ shortcode: "blank",
	+ new_filename: "dir_2/blank_3.png"
	+ })
	+ \|> json_response_and_validate_schema(:bad_request)
	+ end
	+ end
	+end
	diff --git a/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs b/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	index e113bb15f..a34df2c18 100644
	--- a/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	+++ b/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	@@ -1,861 +1,574 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.EmojiPackControllerTest do
	use Pleroma.Web.ConnCase

	import Tesla.Mock
	import Pleroma.Factory

	@emoji_path Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)
	setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false)

	setup do: clear_config([:instance, :public], true)

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	admin_conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	Pleroma.Emoji.reload()
	{:ok, %{admin_conn: admin_conn}}
	end

	test "GET /api/pleroma/emoji/packs when :public: false", %{conn: conn} do
	Config.put([:instance, :public], false)
	conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)
	end

	test "GET /api/pleroma/emoji/packs", %{conn: conn} do
	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)

	assert resp["count"] == 3

	assert resp["packs"]
	\|> Map.keys()
	\|> length() == 3

	shared = resp["packs"]["test_pack"]
	assert shared["files"] == %{"blank" => "blank.png", "blank2" => "blank2.png"}
	assert Map.has_key?(shared["pack"], "download-sha256")
	assert shared["pack"]["can-download"]
	assert shared["pack"]["share-files"]

	non_shared = resp["packs"]["test_pack_nonshared"]
	assert non_shared["pack"]["share-files"] == false
	assert non_shared["pack"]["can-download"] == false

	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page_size=1")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 3

	packs = Map.keys(resp["packs"])

	assert length(packs) == 1

	[pack1] = packs

	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page_size=1&page=2")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 3
	packs = Map.keys(resp["packs"])
	assert length(packs) == 1
	[pack2] = packs

	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page_size=1&page=3")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 3
	packs = Map.keys(resp["packs"])
	assert length(packs) == 1
	[pack3] = packs
	assert [pack1, pack2, pack3] \|> Enum.uniq() \|> length() == 3
	end

	describe "GET /api/pleroma/emoji/packs/remote" do
	test "shareable instance", %{admin_conn: admin_conn, conn: conn} do
	resp =
	conn
	\|> get("/api/pleroma/emoji/packs")
	\|> json_response_and_validate_schema(200)

	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{method: :get, url: "https://example.com/api/pleroma/emoji/packs"} ->
	json(resp)
	end)

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
	\|> json_response_and_validate_schema(200) == resp
	end

	test "non shareable instance", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: []}})
	end)

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
	\|> json_response_and_validate_schema(500) == %{
	"error" => "The requested instance does not support sharing emoji packs"
	}
	end
	end

	describe "GET /api/pleroma/emoji/packs/:name/archive" do
	test "download shared pack", %{conn: conn} do
	resp =
	conn
	\|> get("/api/pleroma/emoji/packs/test_pack/archive")
	\|> response(200)

	{:ok, arch} = :zip.unzip(resp, [:memory])

	assert Enum.find(arch, fn {n, _} -> n == 'pack.json' end)
	assert Enum.find(arch, fn {n, _} -> n == 'blank.png' end)
	end

	test "non existing pack", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/emoji/packs/test_pack_for_import/archive")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack test_pack_for_import does not exist"
	}
	end

	test "non downloadable pack", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/emoji/packs/test_pack_nonshared/archive")
	\|> json_response_and_validate_schema(:forbidden) == %{
	"error" =>
	"Pack test_pack_nonshared cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
	}
	end
	end

	describe "POST /api/pleroma/emoji/packs/download" do
	test "shared pack from remote and non shared from fallback-src", %{
	admin_conn: admin_conn,
	conn: conn
	} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	url: "https://example.com/api/pleroma/emoji/packs/test_pack"
	} ->
	conn
	\|> get("/api/pleroma/emoji/packs/test_pack")
	\|> json_response_and_validate_schema(200)
	\|> json()

	%{
	method: :get,
	url: "https://example.com/api/pleroma/emoji/packs/test_pack/archive"
	} ->
	conn
	\|> get("/api/pleroma/emoji/packs/test_pack/archive")
	\|> response(200)
	\|> text()

	%{
	method: :get,
	url: "https://example.com/api/pleroma/emoji/packs/test_pack_nonshared"
	} ->
	conn
	\|> get("/api/pleroma/emoji/packs/test_pack_nonshared")
	\|> json_response_and_validate_schema(200)
	\|> json()

	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "test_pack",
	as: "test_pack2"
	})
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_pack2/pack.json")
	assert File.exists?("#{@emoji_path}/test_pack2/blank.png")

	assert admin_conn
	\|> delete("/api/pleroma/emoji/packs/test_pack2")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_pack2")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/pleroma/emoji/packs/download",
	%{
	url: "https://example.com",
	name: "test_pack_nonshared",
	as: "test_pack_nonshared2"
	}
	)
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_pack_nonshared2/pack.json")
	assert File.exists?("#{@emoji_path}/test_pack_nonshared2/blank.png")

	assert admin_conn
	\|> delete("/api/pleroma/emoji/packs/test_pack_nonshared2")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_pack_nonshared2")
	end

	test "nonshareable instance", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://old-instance/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://old-instance/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://old-instance/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: []}})
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/pleroma/emoji/packs/download",
	%{
	url: "https://old-instance",
	name: "test_pack",
	as: "test_pack2"
	}
	)
	\|> json_response_and_validate_schema(500) == %{
	"error" => "The requested instance does not support sharing emoji packs"
	}
	end

	test "checksum fail", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	url: "https://example.com/api/pleroma/emoji/packs/pack_bad_sha"
	} ->
	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("pack_bad_sha")
	%Tesla.Env{status: 200, body: Jason.encode!(pack)}

	%{
	method: :get,
	url: "https://example.com/api/pleroma/emoji/packs/pack_bad_sha/archive"
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/instance_static/emoji/pack_bad_sha/pack_bad_sha.zip")
	}
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "pack_bad_sha",
	as: "pack_bad_sha2"
	})
	\|> json_response_and_validate_schema(:internal_server_error) == %{
	"error" => "SHA256 for the pack doesn't match the one sent by the server"
	}
	end

	test "other error", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	url: "https://example.com/api/pleroma/emoji/packs/test_pack"
	} ->
	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("test_pack")
	%Tesla.Env{status: 200, body: Jason.encode!(pack)}
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "test_pack",
	as: "test_pack2"
	})
	\|> json_response_and_validate_schema(:internal_server_error) == %{
	"error" =>
	"The pack was not set as shared and there is no fallback src to download from"
	}
	end
	end

	describe "PATCH /api/pleroma/emoji/packs/:name" do
	setup do
	pack_file = "#{@emoji_path}/test_pack/pack.json"
	original_content = File.read!(pack_file)

	on_exit(fn ->
	File.write!(pack_file, original_content)
	end)

	{:ok,
	pack_file: pack_file,
	new_data: %{
	"license" => "Test license changed",
	"homepage" => "https://pleroma.social",
	"description" => "Test description",
	"share-files" => false
	}}
	end

	test "for a pack without a fallback source", ctx do
	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/pleroma/emoji/packs/test_pack", %{"metadata" => ctx[:new_data]})
	\|> json_response_and_validate_schema(200) == ctx[:new_data]

	assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == ctx[:new_data]
	end

	test "for a pack with a fallback source", ctx do
	mock(fn
	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
	end)

	new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")

	new_data_with_sha =
	Map.put(
	new_data,
	"fallback-src-sha256",
	"1967BB4E42BCC34BCC12D57BE7811D3B7BE52F965BCE45C87BD377B9499CE11D"
	)

	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/pleroma/emoji/packs/test_pack", %{metadata: new_data})
	\|> json_response_and_validate_schema(200) == new_data_with_sha

	assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == new_data_with_sha
	end

	test "when the fallback source doesn't have all the files", ctx do
	mock(fn
	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	{:ok, {'empty.zip', empty_arch}} = :zip.zip('empty.zip', [], [:memory])
	text(empty_arch)
	end)

	new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")

	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/pleroma/emoji/packs/test_pack", %{metadata: new_data})
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "The fallback archive does not have all files specified in pack.json"
	}
	end
	end

	- describe "POST/PATCH/DELETE /api/pleroma/emoji/packs/:name/files" do
	- setup do
	- pack_file = "#{@emoji_path}/test_pack/pack.json"
	- original_content = File.read!(pack_file)
	-
	- on_exit(fn ->
	- File.write!(pack_file, original_content)
	- end)
	-
	- :ok
	- end
	-
	- test "create shortcode exists", %{admin_conn: admin_conn} do
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank",
	- filename: "dir/blank.png",
	- file: %Plug.Upload{
	- filename: "blank.png",
	- path: "#{@emoji_path}/test_pack/blank.png"
	- }
	- })
	- \|> json_response_and_validate_schema(:conflict) == %{
	- "error" => "An emoji with the \"blank\" shortcode already exists"
	- }
	- end
	-
	- test "don't rewrite old emoji", %{admin_conn: admin_conn} do
	- on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir/") end)
	-
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank3",
	- filename: "dir/blank.png",
	- file: %Plug.Upload{
	- filename: "blank.png",
	- path: "#{@emoji_path}/test_pack/blank.png"
	- }
	- })
	- \|> json_response_and_validate_schema(200) == %{
	- "blank" => "blank.png",
	- "blank2" => "blank2.png",
	- "blank3" => "dir/blank.png"
	- }
	-
	- assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
	-
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank",
	- new_shortcode: "blank2",
	- new_filename: "dir_2/blank_3.png"
	- })
	- \|> json_response_and_validate_schema(:conflict) == %{
	- "error" =>
	- "New shortcode \"blank2\" is already used. If you want to override emoji use 'force' option"
	- }
	- end
	-
	- test "rewrite old emoji with force option", %{admin_conn: admin_conn} do
	- on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir_2/") end)
	-
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank3",
	- filename: "dir/blank.png",
	- file: %Plug.Upload{
	- filename: "blank.png",
	- path: "#{@emoji_path}/test_pack/blank.png"
	- }
	- })
	- \|> json_response_and_validate_schema(200) == %{
	- "blank" => "blank.png",
	- "blank2" => "blank2.png",
	- "blank3" => "dir/blank.png"
	- }
	-
	- assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
	-
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank3",
	- new_shortcode: "blank4",
	- new_filename: "dir_2/blank_3.png",
	- force: true
	- })
	- \|> json_response_and_validate_schema(200) == %{
	- "blank" => "blank.png",
	- "blank2" => "blank2.png",
	- "blank4" => "dir_2/blank_3.png"
	- }
	-
	- assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
	- end
	-
	- test "with empty filename", %{admin_conn: admin_conn} do
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank2",
	- filename: "",
	- file: %Plug.Upload{
	- filename: "blank.png",
	- path: "#{@emoji_path}/test_pack/blank.png"
	- }
	- })
	- \|> json_response_and_validate_schema(:bad_request) == %{
	- "error" => "pack name, shortcode or filename cannot be empty"
	- }
	- end
	-
	- test "add file with not loaded pack", %{admin_conn: admin_conn} do
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/not_loaded/files", %{
	- shortcode: "blank3",
	- filename: "dir/blank.png",
	- file: %Plug.Upload{
	- filename: "blank.png",
	- path: "#{@emoji_path}/test_pack/blank.png"
	- }
	- })
	- \|> json_response_and_validate_schema(:bad_request) == %{
	- "error" => "pack \"not_loaded\" is not found"
	- }
	- end
	-
	- test "remove file with not loaded pack", %{admin_conn: admin_conn} do
	- assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/not_loaded/files?shortcode=blank3")
	- \|> json_response_and_validate_schema(:bad_request) == %{
	- "error" => "pack \"not_loaded\" is not found"
	- }
	- end
	-
	- test "remove file with empty shortcode", %{admin_conn: admin_conn} do
	- assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/not_loaded/files?shortcode=")
	- \|> json_response_and_validate_schema(:bad_request) == %{
	- "error" => "pack name or shortcode cannot be empty"
	- }
	- end
	-
	- test "update file with not loaded pack", %{admin_conn: admin_conn} do
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/not_loaded/files", %{
	- shortcode: "blank4",
	- new_shortcode: "blank3",
	- new_filename: "dir_2/blank_3.png"
	- })
	- \|> json_response_and_validate_schema(:bad_request) == %{
	- "error" => "pack \"not_loaded\" is not found"
	- }
	- end
	-
	- test "new with shortcode as file with update", %{admin_conn: admin_conn} do
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank4",
	- filename: "dir/blank.png",
	- file: %Plug.Upload{
	- filename: "blank.png",
	- path: "#{@emoji_path}/test_pack/blank.png"
	- }
	- })
	- \|> json_response_and_validate_schema(200) == %{
	- "blank" => "blank.png",
	- "blank4" => "dir/blank.png",
	- "blank2" => "blank2.png"
	- }
	-
	- assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")
	-
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank4",
	- new_shortcode: "blank3",
	- new_filename: "dir_2/blank_3.png"
	- })
	- \|> json_response_and_validate_schema(200) == %{
	- "blank3" => "dir_2/blank_3.png",
	- "blank" => "blank.png",
	- "blank2" => "blank2.png"
	- }
	-
	- refute File.exists?("#{@emoji_path}/test_pack/dir/")
	- assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
	-
	- assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/test_pack/files?shortcode=blank3")
	- \|> json_response_and_validate_schema(200) == %{
	- "blank" => "blank.png",
	- "blank2" => "blank2.png"
	- }
	-
	- refute File.exists?("#{@emoji_path}/test_pack/dir_2/")
	-
	- on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir") end)
	- end
	-
	- test "new with shortcode from url", %{admin_conn: admin_conn} do
	- mock(fn
	- %{
	- method: :get,
	- url: "https://test-blank/blank_url.png"
	- } ->
	- text(File.read!("#{@emoji_path}/test_pack/blank.png"))
	- end)
	-
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank_url",
	- file: "https://test-blank/blank_url.png"
	- })
	- \|> json_response_and_validate_schema(200) == %{
	- "blank_url" => "blank_url.png",
	- "blank" => "blank.png",
	- "blank2" => "blank2.png"
	- }
	-
	- assert File.exists?("#{@emoji_path}/test_pack/blank_url.png")
	-
	- on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/blank_url.png") end)
	- end
	-
	- test "new without shortcode", %{admin_conn: admin_conn} do
	- on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/shortcode.png") end)
	-
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	- file: %Plug.Upload{
	- filename: "shortcode.png",
	- path: "#{Pleroma.Config.get([:instance, :static_dir])}/add/shortcode.png"
	- }
	- })
	- \|> json_response_and_validate_schema(200) == %{
	- "shortcode" => "shortcode.png",
	- "blank" => "blank.png",
	- "blank2" => "blank2.png"
	- }
	- end
	-
	- test "remove non existing shortcode in pack.json", %{admin_conn: admin_conn} do
	- assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/test_pack/files?shortcode=blank3")
	- \|> json_response_and_validate_schema(:bad_request) == %{
	- "error" => "Emoji \"blank3\" does not exist"
	- }
	- end
	-
	- test "update non existing emoji", %{admin_conn: admin_conn} do
	- assert admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank3",
	- new_shortcode: "blank4",
	- new_filename: "dir_2/blank_3.png"
	- })
	- \|> json_response_and_validate_schema(:bad_request) == %{
	- "error" => "Emoji \"blank3\" does not exist"
	- }
	- end
	-
	- test "update with empty shortcode", %{admin_conn: admin_conn} do
	- assert %{
	- "error" => "Missing field: new_shortcode."
	- } =
	- admin_conn
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	- shortcode: "blank",
	- new_filename: "dir_2/blank_3.png"
	- })
	- \|> json_response_and_validate_schema(:bad_request)
	- end
	- end
	-
	describe "POST/DELETE /api/pleroma/emoji/packs/:name" do
	test "creating and deleting a pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> post("/api/pleroma/emoji/packs/test_created")
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_created/pack.json")

	assert Jason.decode!(File.read!("#{@emoji_path}/test_created/pack.json")) == %{
	"pack" => %{},
	"files" => %{},
	"files_count" => 0
	}

	assert admin_conn
	\|> delete("/api/pleroma/emoji/packs/test_created")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_created/pack.json")
	end

	test "if pack exists", %{admin_conn: admin_conn} do
	path = Path.join(@emoji_path, "test_created")
	File.mkdir(path)
	pack_file = Jason.encode!(%{files: %{}, pack: %{}})
	File.write!(Path.join(path, "pack.json"), pack_file)

	assert admin_conn
	\|> post("/api/pleroma/emoji/packs/test_created")
	\|> json_response_and_validate_schema(:conflict) == %{
	"error" => "A pack named \"test_created\" already exists"
	}

	on_exit(fn -> File.rm_rf(path) end)
	end

	test "with empty name", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> post("/api/pleroma/emoji/packs/ ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end
	end

	test "deleting nonexisting pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> delete("/api/pleroma/emoji/packs/non_existing")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack non_existing does not exist"
	}
	end

	test "deleting with empty name", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> delete("/api/pleroma/emoji/packs/ ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end

	test "filesystem import", %{admin_conn: admin_conn, conn: conn} do
	on_exit(fn ->
	File.rm!("#{@emoji_path}/test_pack_for_import/emoji.txt")
	File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
	end)

	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)

	refute Map.has_key?(resp["packs"], "test_pack_for_import")

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/import")
	\|> json_response_and_validate_schema(200) == ["test_pack_for_import"]

	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)
	assert resp["packs"]["test_pack_for_import"]["files"] == %{"blank" => "blank.png"}

	File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
	refute File.exists?("#{@emoji_path}/test_pack_for_import/pack.json")

	emoji_txt_content = """
	blank, blank.png, Fun
	blank2, blank.png
	foo, /emoji/test_pack_for_import/blank.png
	bar
	"""

	File.write!("#{@emoji_path}/test_pack_for_import/emoji.txt", emoji_txt_content)

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/import")
	\|> json_response_and_validate_schema(200) == ["test_pack_for_import"]

	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)

	assert resp["packs"]["test_pack_for_import"]["files"] == %{
	"blank" => "blank.png",
	"blank2" => "blank.png",
	"foo" => "blank.png"
	}
	end

	describe "GET /api/pleroma/emoji/packs/:name" do
	test "shows pack.json", %{conn: conn} do
	assert %{
	"files" => files,
	"files_count" => 2,
	"pack" => %{
	"can-download" => true,
	"description" => "Test description",
	"download-sha256" => _,
	"homepage" => "https://pleroma.social",
	"license" => "Test license",
	"share-files" => true
	}
	} =
	conn
	\|> get("/api/pleroma/emoji/packs/test_pack")
	\|> json_response_and_validate_schema(200)

	assert files == %{"blank" => "blank.png", "blank2" => "blank2.png"}

	assert %{
	"files" => files,
	"files_count" => 2
	} =
	conn
	\|> get("/api/pleroma/emoji/packs/test_pack?page_size=1")
	\|> json_response_and_validate_schema(200)

	assert files \|> Map.keys() \|> length() == 1

	assert %{
	"files" => files,
	"files_count" => 2
	} =
	conn
	\|> get("/api/pleroma/emoji/packs/test_pack?page_size=1&page=2")
	\|> json_response_and_validate_schema(200)

	assert files \|> Map.keys() \|> length() == 1
	end

	test "non existing pack", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/emoji/packs/non_existing")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack non_existing does not exist"
	}
	end

	test "error name", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/emoji/packs/ ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 5:23 PM (15 h, 54 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1800358
Default Alt Text: (99 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions