No OneTemporary
Actions

Size

58 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_conversation_operation.ex
	similarity index 65%
	copy from lib/pleroma/web/api_spec/operations/pleroma_operation.ex
	copy to lib/pleroma/web/api_spec/operations/pleroma_conversation_operation.ex
	index 7e46ba553..e885eab20 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_conversation_operation.ex
	@@ -1,135 +1,106 @@
	# 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.PleromaOperation do
	+defmodule Pleroma.Web.ApiSpec.PleromaConversationOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	- alias Pleroma.Web.ApiSpec.NotificationOperation
	- alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.Conversation
	alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	alias Pleroma.Web.ApiSpec.StatusOperation

	import Pleroma.Web.ApiSpec.Helpers

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

	- def conversation_operation do
	+ def show_operation do
	%Operation{
	tags: ["Conversations"],
	summary: "The conversation with the given ID",
	parameters: [
	Operation.parameter(:id, :path, :string, "Conversation ID",
	example: "123",
	required: true
	)
	],
	security: [%{"oAuth" => ["read:statuses"]}],
	- operationId: "PleromaController.conversation",
	+ operationId: "PleromaAPI.ConversationController.show",
	responses: %{
	200 => Operation.response("Conversation", "application/json", Conversation)
	}
	}
	end

	- def conversation_statuses_operation do
	+ def statuses_operation do
	%Operation{
	tags: ["Conversations"],
	summary: "Timeline for a given conversation",
	parameters: [
	Operation.parameter(:id, :path, :string, "Conversation ID",
	example: "123",
	required: true
	)
	\| pagination_params()
	],
	security: [%{"oAuth" => ["read:statuses"]}],
	- operationId: "PleromaController.conversation_statuses",
	+ operationId: "PleromaAPI.ConversationController.statuses",
	responses: %{
	200 =>
	Operation.response(
	"Array of Statuses",
	"application/json",
	StatusOperation.array_of_statuses()
	)
	}
	}
	end

	- def update_conversation_operation do
	+ def update_operation do
	%Operation{
	tags: ["Conversations"],
	summary: "Update a conversation. Used to change the set of recipients.",
	parameters: [
	Operation.parameter(:id, :path, :string, "Conversation ID",
	example: "123",
	required: true
	),
	Operation.parameter(
	:recipients,
	:query,
	%Schema{type: :array, items: FlakeID},
	"A list of ids of users that should receive posts to this conversation. This will replace the current list of recipients, so submit the full list. The owner of owner of the conversation will always be part of the set of recipients, though.",
	required: true
	)
	],
	security: [%{"oAuth" => ["write:conversations"]}],
	- operationId: "PleromaController.update_conversation",
	+ operationId: "PleromaAPI.ConversationController.update",
	responses: %{
	200 => Operation.response("Conversation", "application/json", Conversation)
	}
	}
	end

	- def mark_conversations_as_read_operation do
	+ def mark_as_read_operation do
	%Operation{
	tags: ["Conversations"],
	summary: "Marks all user's conversations as read",
	security: [%{"oAuth" => ["write:conversations"]}],
	- operationId: "PleromaController.mark_conversations_as_read",
	+ operationId: "PleromaAPI.ConversationController.mark_as_read",
	responses: %{
	200 =>
	Operation.response(
	"Array of Conversations that were marked as read",
	"application/json",
	%Schema{
	type: :array,
	items: Conversation,
	example: [Conversation.schema().example]
	}
	)
	}
	}
	end
	-
	- def mark_notifications_as_read_operation do
	- %Operation{
	- tags: ["Notifications"],
	- summary: "Mark notifications as read. Query parameters are mutually exclusive.",
	- parameters: [
	- Operation.parameter(:id, :query, :string, "A single notification ID to read"),
	- Operation.parameter(:max_id, :query, :string, "Read all notifications up to this id")
	- ],
	- security: [%{"oAuth" => ["write:notifications"]}],
	- operationId: "PleromaController.mark_notifications_as_read",
	- responses: %{
	- 200 =>
	- Operation.response(
	- "A Notification or array of Motifications",
	- "application/json",
	- %Schema{
	- anyOf: [
	- %Schema{type: :array, items: NotificationOperation.notification()},
	- NotificationOperation.notification()
	- ]
	- }
	- ),
	- 400 => Operation.response("Bad Request", "application/json", ApiError)
	- }
	- }
	- end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_operation.ex
	index 7e46ba553..d28451933 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_operation.ex
	@@ -1,135 +1,42 @@
	# 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.PleromaOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.NotificationOperation
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	- alias Pleroma.Web.ApiSpec.Schemas.Conversation
	- alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	- alias Pleroma.Web.ApiSpec.StatusOperation
	-
	- import Pleroma.Web.ApiSpec.Helpers

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

	- def conversation_operation do
	- %Operation{
	- tags: ["Conversations"],
	- summary: "The conversation with the given ID",
	- parameters: [
	- Operation.parameter(:id, :path, :string, "Conversation ID",
	- example: "123",
	- required: true
	- )
	- ],
	- security: [%{"oAuth" => ["read:statuses"]}],
	- operationId: "PleromaController.conversation",
	- responses: %{
	- 200 => Operation.response("Conversation", "application/json", Conversation)
	- }
	- }
	- end
	-
	- def conversation_statuses_operation do
	- %Operation{
	- tags: ["Conversations"],
	- summary: "Timeline for a given conversation",
	- parameters: [
	- Operation.parameter(:id, :path, :string, "Conversation ID",
	- example: "123",
	- required: true
	- )
	- \| pagination_params()
	- ],
	- security: [%{"oAuth" => ["read:statuses"]}],
	- operationId: "PleromaController.conversation_statuses",
	- responses: %{
	- 200 =>
	- Operation.response(
	- "Array of Statuses",
	- "application/json",
	- StatusOperation.array_of_statuses()
	- )
	- }
	- }
	- end
	-
	- def update_conversation_operation do
	- %Operation{
	- tags: ["Conversations"],
	- summary: "Update a conversation. Used to change the set of recipients.",
	- parameters: [
	- Operation.parameter(:id, :path, :string, "Conversation ID",
	- example: "123",
	- required: true
	- ),
	- Operation.parameter(
	- :recipients,
	- :query,
	- %Schema{type: :array, items: FlakeID},
	- "A list of ids of users that should receive posts to this conversation. This will replace the current list of recipients, so submit the full list. The owner of owner of the conversation will always be part of the set of recipients, though.",
	- required: true
	- )
	- ],
	- security: [%{"oAuth" => ["write:conversations"]}],
	- operationId: "PleromaController.update_conversation",
	- responses: %{
	- 200 => Operation.response("Conversation", "application/json", Conversation)
	- }
	- }
	- end
	-
	- def mark_conversations_as_read_operation do
	- %Operation{
	- tags: ["Conversations"],
	- summary: "Marks all user's conversations as read",
	- security: [%{"oAuth" => ["write:conversations"]}],
	- operationId: "PleromaController.mark_conversations_as_read",
	- responses: %{
	- 200 =>
	- Operation.response(
	- "Array of Conversations that were marked as read",
	- "application/json",
	- %Schema{
	- type: :array,
	- items: Conversation,
	- example: [Conversation.schema().example]
	- }
	- )
	- }
	- }
	- end
	-
	def mark_notifications_as_read_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Mark notifications as read. Query parameters are mutually exclusive.",
	parameters: [
	Operation.parameter(:id, :query, :string, "A single notification ID to read"),
	Operation.parameter(:max_id, :query, :string, "Read all notifications up to this id")
	],
	security: [%{"oAuth" => ["write:notifications"]}],
	operationId: "PleromaController.mark_notifications_as_read",
	responses: %{
	200 =>
	Operation.response(
	"A Notification or array of Motifications",
	"application/json",
	%Schema{
	anyOf: [
	%Schema{type: :array, items: NotificationOperation.notification()},
	NotificationOperation.notification()
	]
	}
	),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/conversation_controller.ex b/lib/pleroma/web/pleroma_api/controllers/conversation_controller.ex
	new file mode 100644
	index 000000000..21d5eb8d5
	--- /dev/null
	+++ b/lib/pleroma/web/pleroma_api/controllers/conversation_controller.ex
	@@ -0,0 +1,95 @@
	+# 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.ConversationController do
	+ use Pleroma.Web, :controller
	+
	+ import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2]
	+
	+ alias Pleroma.Conversation.Participation
	+ alias Pleroma.Plugs.OAuthScopesPlug
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.MastodonAPI.StatusView
	+
	+ plug(Pleroma.Web.ApiSpec.CastAndValidate)
	+ plug(:put_view, Pleroma.Web.MastodonAPI.ConversationView)
	+ plug(OAuthScopesPlug, %{scopes: ["read:statuses"]} when action in [:show, :statuses])
	+
	+ plug(
	+ OAuthScopesPlug,
	+ %{scopes: ["write:conversations"]} when action in [:update, :mark_as_read]
	+ )
	+
	+ defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.PleromaConversationOperation
	+
	+ def show(%{assigns: %{user: %{id: user_id} = user}} = conn, %{id: participation_id}) do
	+ with %Participation{user_id: ^user_id} = participation <- Participation.get(participation_id) do
	+ render(conn, "participation.json", participation: participation, for: user)
	+ else
	+ _error ->
	+ conn
	+ \|> put_status(:not_found)
	+ \|> json(%{"error" => "Unknown conversation id"})
	+ end
	+ end
	+
	+ def statuses(
	+ %{assigns: %{user: %{id: user_id} = user}} = conn,
	+ %{id: participation_id} = params
	+ ) do
	+ with %Participation{user_id: ^user_id} = participation <-
	+ Participation.get(participation_id, preload: [:conversation]) do
	+ params =
	+ params
	+ \|> Map.new(fn {key, value} -> {to_string(key), value} end)
	+ \|> Map.put("blocking_user", user)
	+ \|> Map.put("muting_user", user)
	+ \|> Map.put("user", user)
	+
	+ activities =
	+ participation.conversation.ap_id
	+ \|> ActivityPub.fetch_activities_for_context_query(params)
	+ \|> Pleroma.Pagination.fetch_paginated(Map.put(params, "total", false))
	+ \|> Enum.reverse()
	+
	+ conn
	+ \|> add_link_headers(activities)
	+ \|> put_view(StatusView)
	+ \|> render("index.json", activities: activities, for: user, as: :activity)
	+ else
	+ _error ->
	+ conn
	+ \|> put_status(:not_found)
	+ \|> json(%{"error" => "Unknown conversation id"})
	+ end
	+ end
	+
	+ def update(
	+ %{assigns: %{user: %{id: user_id} = user}} = conn,
	+ %{id: participation_id, recipients: recipients}
	+ ) do
	+ with %Participation{user_id: ^user_id} = participation <- Participation.get(participation_id),
	+ {:ok, participation} <- Participation.set_recipients(participation, recipients) do
	+ render(conn, "participation.json", participation: participation, for: user)
	+ else
	+ {:error, message} ->
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{"error" => message})
	+
	+ _error ->
	+ conn
	+ \|> put_status(:not_found)
	+ \|> json(%{"error" => "Unknown conversation id"})
	+ end
	+ end
	+
	+ def mark_as_read(%{assigns: %{user: user}} = conn, _params) do
	+ with {:ok, _, participations} <- Participation.mark_all_as_read(user) do
	+ conn
	+ \|> add_link_headers(participations)
	+ \|> render("participations.json", participations: participations, for: user)
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/pleroma_api_controller.ex b/lib/pleroma/web/pleroma_api/controllers/pleroma_api_controller.ex
	index 61273f7ee..a58665abe 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/pleroma_api_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/pleroma_api_controller.ex
	@@ -1,145 +1,46 @@
	# 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.PleromaAPIController do
	use Pleroma.Web, :controller

	- import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2]
	-
	- alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Plugs.OAuthScopesPlug
	- alias Pleroma.Web.ActivityPub.ActivityPub
	- alias Pleroma.Web.MastodonAPI.ConversationView
	alias Pleroma.Web.MastodonAPI.NotificationView
	- alias Pleroma.Web.MastodonAPI.StatusView

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	- plug(
	- OAuthScopesPlug,
	- %{scopes: ["read:statuses"]}
	- when action in [:conversation, :conversation_statuses]
	- )
	-
	- plug(
	- OAuthScopesPlug,
	- %{scopes: ["write:conversations"]}
	- when action in [:update_conversation, :mark_conversations_as_read]
	- )
	-
	plug(
	OAuthScopesPlug,
	%{scopes: ["write:notifications"]} when action == :mark_notifications_as_read
	)

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

	- def conversation(%{assigns: %{user: user}} = conn, %{id: participation_id}) do
	- with %Participation{} = participation <- Participation.get(participation_id),
	- true <- user.id == participation.user_id do
	- conn
	- \|> put_view(ConversationView)
	- \|> render("participation.json", %{participation: participation, for: user})
	- else
	- _error ->
	- conn
	- \|> put_status(404)
	- \|> json(%{"error" => "Unknown conversation id"})
	- end
	- end
	-
	- def conversation_statuses(
	- %{assigns: %{user: %{id: user_id} = user}} = conn,
	- %{id: participation_id} = params
	- ) do
	- with %Participation{user_id: ^user_id} = participation <-
	- Participation.get(participation_id, preload: [:conversation]) do
	- params =
	- params
	- \|> Map.new(fn {key, value} -> {to_string(key), value} end)
	- \|> Map.put("blocking_user", user)
	- \|> Map.put("muting_user", user)
	- \|> Map.put("user", user)
	-
	- activities =
	- participation.conversation.ap_id
	- \|> ActivityPub.fetch_activities_for_context_query(params)
	- \|> Pleroma.Pagination.fetch_paginated(Map.put(params, "total", false))
	- \|> Enum.reverse()
	-
	- conn
	- \|> add_link_headers(activities)
	- \|> put_view(StatusView)
	- \|> render("index.json",
	- activities: activities,
	- for: user,
	- as: :activity
	- )
	- else
	- _error ->
	- conn
	- \|> put_status(404)
	- \|> json(%{"error" => "Unknown conversation id"})
	- end
	- end
	-
	- def update_conversation(
	- %{assigns: %{user: user}} = conn,
	- %{id: participation_id, recipients: recipients}
	- ) do
	- with %Participation{} = participation <- Participation.get(participation_id),
	- true <- user.id == participation.user_id,
	- {:ok, participation} <- Participation.set_recipients(participation, recipients) do
	- conn
	- \|> put_view(ConversationView)
	- \|> render("participation.json", %{participation: participation, for: user})
	- else
	- {:error, message} ->
	- conn
	- \|> put_status(:bad_request)
	- \|> json(%{"error" => message})
	-
	- _error ->
	- conn
	- \|> put_status(404)
	- \|> json(%{"error" => "Unknown conversation id"})
	- end
	- end
	-
	- def mark_conversations_as_read(%{assigns: %{user: user}} = conn, _params) do
	- with {:ok, _, participations} <- Participation.mark_all_as_read(user) do
	- conn
	- \|> add_link_headers(participations)
	- \|> put_view(ConversationView)
	- \|> render("participations.json", participations: participations, for: user)
	- end
	- end
	-
	def mark_notifications_as_read(%{assigns: %{user: user}} = conn, %{id: notification_id}) do
	with {:ok, notification} <- Notification.read_one(user, notification_id) do
	conn
	\|> put_view(NotificationView)
	\|> render("show.json", %{notification: notification, for: user})
	else
	{:error, message} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{"error" => message})
	end
	end

	def mark_notifications_as_read(%{assigns: %{user: user}} = conn, %{max_id: max_id}) do
	with notifications <- Notification.set_read_up_to(user, max_id) do
	notifications = Enum.take(notifications, 80)

	conn
	\|> put_view(NotificationView)
	\|> render("index.json",
	notifications: notifications,
	for: user
	)
	end
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index 12381511e..78da4a871 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,722 +1,718 @@
	# 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)
	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", AdminAPIController, :relay_list)
	post("/relay", AdminAPIController, :relay_follow)
	delete("/relay", AdminAPIController, :relay_unfollow)

	post("/users/invite_token", AdminAPIController, :create_invite_token)
	get("/users/invites", AdminAPIController, :invites)
	post("/users/revoke_invite", AdminAPIController, :revoke_invite)
	post("/users/email_invite", AdminAPIController, :email_invite)

	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", AdminAPIController, :list_reports)
	get("/reports/:id", AdminAPIController, :report_show)
	patch("/reports", AdminAPIController, :reports_update)
	post("/reports/:id/notes", AdminAPIController, :report_notes_create)
	delete("/reports/:report_id/notes/:id", AdminAPIController, :report_notes_delete)

	get("/statuses/:id", AdminAPIController, :status_show)
	put("/statuses/:id", AdminAPIController, :status_update)
	delete("/statuses/:id", AdminAPIController, :status_delete)
	get("/statuses", AdminAPIController, :list_statuses)

	get("/config", AdminAPIController, :config_show)
	post("/config", AdminAPIController, :config_update)
	get("/config/descriptions", AdminAPIController, :config_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", AdminAPIController, :oauth_app_list)
	post("/oauth_app", AdminAPIController, :oauth_app_create)
	patch("/oauth_app/:id", AdminAPIController, :oauth_app_update)
	delete("/oauth_app/:id", AdminAPIController, :oauth_app_delete)
	end

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

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

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

	post("/:name/files", EmojiAPIController, :add_file)
	patch("/:name/files", EmojiAPIController, :update_file)
	delete("/:name/files", EmojiAPIController, :delete_file)
	end

	# Pack info / downloading
	scope "/packs" do
	get("/", EmojiAPIController, :list)
	get("/:name", EmojiAPIController, :show)
	get("/:name/archive", EmojiAPIController, :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)

	- get("/conversations/:id/statuses", PleromaAPIController, :conversation_statuses)
	- get("/conversations/:id", PleromaAPIController, :conversation)
	- post("/conversations/read", PleromaAPIController, :mark_conversations_as_read)
	- end
	-
	- scope [] do
	- pipe_through(:authenticated_api)
	+ get("/conversations/:id/statuses", ConversationController, :statuses)
	+ get("/conversations/:id", ConversationController, :show)
	+ post("/conversations/read", ConversationController, :mark_as_read)
	+ patch("/conversations/:id", ConversationController, :update)

	- patch("/conversations/:id", PleromaAPIController, :update_conversation)
	put("/statuses/:id/reactions/:emoji", EmojiReactionController, :create)
	delete("/statuses/:id/reactions/:emoji", EmojiReactionController, :delete)
	post("/notifications/read", PleromaAPIController, :mark_notifications_as_read)

	patch("/accounts/update_avatar", AccountController, :update_avatar)
	patch("/accounts/update_banner", AccountController, :update_banner)
	patch("/accounts/update_background", AccountController, :update_background)

	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)

	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("/help/test", TwitterAPI.UtilController, :help_test)
	post("/help/test", TwitterAPI.UtilController, :help_test)
	get("/statusnet/config", TwitterAPI.UtilController, :config)
	get("/statusnet/version", TwitterAPI.UtilController, :version)
	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)

	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

	scope "/", Pleroma.Web.ActivityPub do
	# XXX: not really ostatus
	pipe_through(:ostatus)

	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	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)

	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)
	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)

	options("/*path", RedirectController, :empty)
	end
	end
	diff --git a/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs b/test/web/pleroma_api/controllers/conversation_controller_test.exs
	similarity index 66%
	copy from test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
	copy to test/web/pleroma_api/controllers/conversation_controller_test.exs
	index 6f4f01e6f..e6d0b3e37 100644
	--- a/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
	+++ b/test/web/pleroma_api/controllers/conversation_controller_test.exs
	@@ -1,187 +1,136 @@
	# 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.PleromaAPIControllerTest do
	+defmodule Pleroma.Web.PleromaAPI.ConversationControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Conversation.Participation
	- alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "/api/v1/pleroma/conversations/:id" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:statuses"])

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}!", visibility: "direct"})

	[participation] = Participation.for_user(other_user)

	result =
	conn
	\|> get("/api/v1/pleroma/conversations/#{participation.id}")
	\|> json_response_and_validate_schema(200)

	assert result["id"] == participation.id \|> to_string()
	end

	test "/api/v1/pleroma/conversations/:id/statuses" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:statuses"])
	third_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "Hi @#{third_user.nickname}!", visibility: "direct"})

	{:ok, activity} =
	CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}!", visibility: "direct"})

	[participation] = Participation.for_user(other_user)

	{:ok, activity_two} =
	CommonAPI.post(other_user, %{
	status: "Hi!",
	in_reply_to_status_id: activity.id,
	in_reply_to_conversation_id: participation.id
	})

	result =
	conn
	\|> get("/api/v1/pleroma/conversations/#{participation.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 2

	id_one = activity.id
	id_two = activity_two.id
	assert [%{"id" => ^id_one}, %{"id" => ^id_two}] = result

	{:ok, %{id: id_three}} =
	CommonAPI.post(other_user, %{
	status: "Bye!",
	in_reply_to_status_id: activity.id,
	in_reply_to_conversation_id: participation.id
	})

	assert [%{"id" => ^id_two}, %{"id" => ^id_three}] =
	conn
	\|> get("/api/v1/pleroma/conversations/#{participation.id}/statuses?limit=2")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^id_three}] =
	conn
	\|> get("/api/v1/pleroma/conversations/#{participation.id}/statuses?min_id=#{id_two}")
	\|> json_response_and_validate_schema(:ok)
	end

	test "PATCH /api/v1/pleroma/conversations/:id" do
	%{user: user, conn: conn} = oauth_access(["write:conversations"])
	other_user = insert(:user)

	{:ok, _activity} = CommonAPI.post(user, %{status: "Hi", visibility: "direct"})

	[participation] = Participation.for_user(user)

	participation = Repo.preload(participation, :recipients)

	user = User.get_cached_by_id(user.id)
	assert [user] == participation.recipients
	assert other_user not in participation.recipients

	query = "recipients[]=#{user.id}&recipients[]=#{other_user.id}"

	result =
	conn
	\|> patch("/api/v1/pleroma/conversations/#{participation.id}?#{query}")
	\|> json_response_and_validate_schema(200)

	assert result["id"] == participation.id \|> to_string

	[participation] = Participation.for_user(user)
	participation = Repo.preload(participation, :recipients)

	assert user in participation.recipients
	assert other_user in participation.recipients
	end

	test "POST /api/v1/pleroma/conversations/read" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["write:conversations"])

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}", visibility: "direct"})

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}", visibility: "direct"})

	[participation2, participation1] = Participation.for_user(other_user)
	assert Participation.get(participation2.id).read == false
	assert Participation.get(participation1.id).read == false
	assert User.get_cached_by_id(other_user.id).unread_conversation_count == 2

	[%{"unread" => false}, %{"unread" => false}] =
	conn
	\|> post("/api/v1/pleroma/conversations/read", %{})
	\|> json_response_and_validate_schema(200)

	[participation2, participation1] = Participation.for_user(other_user)
	assert Participation.get(participation2.id).read == true
	assert Participation.get(participation1.id).read == true
	assert User.get_cached_by_id(other_user.id).unread_conversation_count == 0
	end
	-
	- describe "POST /api/v1/pleroma/notifications/read" do
	- setup do: oauth_access(["write:notifications"])
	-
	- test "it marks a single notification as read", %{user: user1, conn: conn} do
	- user2 = insert(:user)
	- {:ok, activity1} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
	- {:ok, activity2} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
	- {:ok, [notification1]} = Notification.create_notifications(activity1)
	- {:ok, [notification2]} = Notification.create_notifications(activity2)
	-
	- response =
	- conn
	- \|> post("/api/v1/pleroma/notifications/read?id=#{notification1.id}")
	- \|> json_response_and_validate_schema(:ok)
	-
	- assert %{"pleroma" => %{"is_seen" => true}} = response
	- assert Repo.get(Notification, notification1.id).seen
	- refute Repo.get(Notification, notification2.id).seen
	- end
	-
	- test "it marks multiple notifications as read", %{user: user1, conn: conn} do
	- user2 = insert(:user)
	- {:ok, _activity1} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
	- {:ok, _activity2} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
	- {:ok, _activity3} = CommonAPI.post(user2, %{status: "HIE @#{user1.nickname}"})
	-
	- [notification3, notification2, notification1] = Notification.for_user(user1, %{limit: 3})
	-
	- [response1, response2] =
	- conn
	- \|> post("/api/v1/pleroma/notifications/read?max_id=#{notification2.id}")
	- \|> json_response_and_validate_schema(:ok)
	-
	- assert %{"pleroma" => %{"is_seen" => true}} = response1
	- assert %{"pleroma" => %{"is_seen" => true}} = response2
	- assert Repo.get(Notification, notification1.id).seen
	- assert Repo.get(Notification, notification2.id).seen
	- refute Repo.get(Notification, notification3.id).seen
	- end
	-
	- test "it returns error when notification not found", %{conn: conn} do
	- response =
	- conn
	- \|> post("/api/v1/pleroma/notifications/read?id=22222222222222")
	- \|> json_response_and_validate_schema(:bad_request)
	-
	- assert response == %{"error" => "Cannot get notification"}
	- end
	- end
	end
	diff --git a/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs b/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
	index 6f4f01e6f..c4c661266 100644
	--- a/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
	+++ b/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
	@@ -1,187 +1,63 @@
	# 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.PleromaAPIControllerTest do
	use Pleroma.Web.ConnCase

	- alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Repo
	- alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	- test "/api/v1/pleroma/conversations/:id" do
	- user = insert(:user)
	- %{user: other_user, conn: conn} = oauth_access(["read:statuses"])
	-
	- {:ok, _activity} =
	- CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}!", visibility: "direct"})
	-
	- [participation] = Participation.for_user(other_user)
	-
	- result =
	- conn
	- \|> get("/api/v1/pleroma/conversations/#{participation.id}")
	- \|> json_response_and_validate_schema(200)
	-
	- assert result["id"] == participation.id \|> to_string()
	- end
	-
	- test "/api/v1/pleroma/conversations/:id/statuses" do
	- user = insert(:user)
	- %{user: other_user, conn: conn} = oauth_access(["read:statuses"])
	- third_user = insert(:user)
	-
	- {:ok, _activity} =
	- CommonAPI.post(user, %{status: "Hi @#{third_user.nickname}!", visibility: "direct"})
	-
	- {:ok, activity} =
	- CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}!", visibility: "direct"})
	-
	- [participation] = Participation.for_user(other_user)
	-
	- {:ok, activity_two} =
	- CommonAPI.post(other_user, %{
	- status: "Hi!",
	- in_reply_to_status_id: activity.id,
	- in_reply_to_conversation_id: participation.id
	- })
	-
	- result =
	- conn
	- \|> get("/api/v1/pleroma/conversations/#{participation.id}/statuses")
	- \|> json_response_and_validate_schema(200)
	-
	- assert length(result) == 2
	-
	- id_one = activity.id
	- id_two = activity_two.id
	- assert [%{"id" => ^id_one}, %{"id" => ^id_two}] = result
	-
	- {:ok, %{id: id_three}} =
	- CommonAPI.post(other_user, %{
	- status: "Bye!",
	- in_reply_to_status_id: activity.id,
	- in_reply_to_conversation_id: participation.id
	- })
	-
	- assert [%{"id" => ^id_two}, %{"id" => ^id_three}] =
	- conn
	- \|> get("/api/v1/pleroma/conversations/#{participation.id}/statuses?limit=2")
	- \|> json_response_and_validate_schema(:ok)
	-
	- assert [%{"id" => ^id_three}] =
	- conn
	- \|> get("/api/v1/pleroma/conversations/#{participation.id}/statuses?min_id=#{id_two}")
	- \|> json_response_and_validate_schema(:ok)
	- end
	-
	- test "PATCH /api/v1/pleroma/conversations/:id" do
	- %{user: user, conn: conn} = oauth_access(["write:conversations"])
	- other_user = insert(:user)
	-
	- {:ok, _activity} = CommonAPI.post(user, %{status: "Hi", visibility: "direct"})
	-
	- [participation] = Participation.for_user(user)
	-
	- participation = Repo.preload(participation, :recipients)
	-
	- user = User.get_cached_by_id(user.id)
	- assert [user] == participation.recipients
	- assert other_user not in participation.recipients
	-
	- query = "recipients[]=#{user.id}&recipients[]=#{other_user.id}"
	-
	- result =
	- conn
	- \|> patch("/api/v1/pleroma/conversations/#{participation.id}?#{query}")
	- \|> json_response_and_validate_schema(200)
	-
	- assert result["id"] == participation.id \|> to_string
	-
	- [participation] = Participation.for_user(user)
	- participation = Repo.preload(participation, :recipients)
	-
	- assert user in participation.recipients
	- assert other_user in participation.recipients
	- end
	-
	- test "POST /api/v1/pleroma/conversations/read" do
	- user = insert(:user)
	- %{user: other_user, conn: conn} = oauth_access(["write:conversations"])
	-
	- {:ok, _activity} =
	- CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}", visibility: "direct"})
	-
	- {:ok, _activity} =
	- CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}", visibility: "direct"})
	-
	- [participation2, participation1] = Participation.for_user(other_user)
	- assert Participation.get(participation2.id).read == false
	- assert Participation.get(participation1.id).read == false
	- assert User.get_cached_by_id(other_user.id).unread_conversation_count == 2
	-
	- [%{"unread" => false}, %{"unread" => false}] =
	- conn
	- \|> post("/api/v1/pleroma/conversations/read", %{})
	- \|> json_response_and_validate_schema(200)
	-
	- [participation2, participation1] = Participation.for_user(other_user)
	- assert Participation.get(participation2.id).read == true
	- assert Participation.get(participation1.id).read == true
	- assert User.get_cached_by_id(other_user.id).unread_conversation_count == 0
	- end
	-
	describe "POST /api/v1/pleroma/notifications/read" do
	setup do: oauth_access(["write:notifications"])

	test "it marks a single notification as read", %{user: user1, conn: conn} do
	user2 = insert(:user)
	{:ok, activity1} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
	{:ok, activity2} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
	{:ok, [notification1]} = Notification.create_notifications(activity1)
	{:ok, [notification2]} = Notification.create_notifications(activity2)

	response =
	conn
	\|> post("/api/v1/pleroma/notifications/read?id=#{notification1.id}")
	\|> json_response_and_validate_schema(:ok)

	assert %{"pleroma" => %{"is_seen" => true}} = response
	assert Repo.get(Notification, notification1.id).seen
	refute Repo.get(Notification, notification2.id).seen
	end

	test "it marks multiple notifications as read", %{user: user1, conn: conn} do
	user2 = insert(:user)
	{:ok, _activity1} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
	{:ok, _activity2} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
	{:ok, _activity3} = CommonAPI.post(user2, %{status: "HIE @#{user1.nickname}"})

	[notification3, notification2, notification1] = Notification.for_user(user1, %{limit: 3})

	[response1, response2] =
	conn
	\|> post("/api/v1/pleroma/notifications/read?max_id=#{notification2.id}")
	\|> json_response_and_validate_schema(:ok)

	assert %{"pleroma" => %{"is_seen" => true}} = response1
	assert %{"pleroma" => %{"is_seen" => true}} = response2
	assert Repo.get(Notification, notification1.id).seen
	assert Repo.get(Notification, notification2.id).seen
	refute Repo.get(Notification, notification3.id).seen
	end

	test "it returns error when notification not found", %{conn: conn} do
	response =
	conn
	\|> post("/api/v1/pleroma/notifications/read?id=22222222222222")
	\|> json_response_and_validate_schema(:bad_request)

	assert response == %{"error" => "Cannot get notification"}
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 30, 9:49 PM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1738176
Default Alt Text: (58 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions