No OneTemporary
Actions

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/admin_api/controllers/o_auth_app_controller.ex b/lib/pleroma/web/admin_api/controllers/o_auth_app_controller.ex
	index 005fe67e2..51b17d392 100644
	--- a/lib/pleroma/web/admin_api/controllers/o_auth_app_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/o_auth_app_controller.ex
	@@ -1,77 +1,76 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	require Logger

	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	- plug(:put_view, Pleroma.Web.MastodonAPI.AppView)

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:write"]}
	when action in [:create, :index, :update, :delete]
	)

	action_fallback(Pleroma.Web.AdminAPI.FallbackController)

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

	def index(conn, params) do
	search_params =
	params
	\|> Map.take([:client_id, :page, :page_size, :trusted])
	\|> Map.put(:client_name, params[:name])

	with {:ok, apps, count} <- App.search(search_params) do
	render(conn, "index.json",
	apps: apps,
	count: count,
	page_size: params.page_size,
	admin: true
	)
	end
	end

	def create(%{body_params: params} = conn, _) do
	params = Pleroma.Maps.put_if_present(params, :client_name, params[:name])

	case App.create(params) do
	{:ok, app} ->
	render(conn, "show.json", app: app, admin: true)

	{:error, changeset} ->
	json(conn, App.errors(changeset))
	end
	end

	def update(%{body_params: params} = conn, %{id: id}) do
	params = Pleroma.Maps.put_if_present(params, :client_name, params[:name])

	with {:ok, app} <- App.update(id, params) do
	render(conn, "show.json", app: app, admin: true)
	else
	{:error, changeset} ->
	json(conn, App.errors(changeset))

	nil ->
	json_response(conn, :bad_request, "")
	end
	end

	def delete(conn, params) do
	with {:ok, _app} <- App.destroy(params.id) do
	json_response(conn, :no_content, "")
	else
	_ -> json_response(conn, :bad_request, "")
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/views/o_auth_app_view.ex b/lib/pleroma/web/admin_api/views/o_auth_app_view.ex
	new file mode 100644
	index 000000000..af046f343
	--- /dev/null
	+++ b/lib/pleroma/web/admin_api/views/o_auth_app_view.ex
	@@ -0,0 +1,10 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.AdminAPI.OAuthAppView do
	+ use Pleroma.Web, :view
	+ alias Pleroma.Web.MastodonAPI
	+
	+ def render(view, opts), do: MastodonAPI.AppView.render(view, opts)
	+end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/follow_request_controller.ex b/lib/pleroma/web/mastodon_api/controllers/follow_request_controller.ex
	index 63d0e2c35..d915298f1 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/follow_request_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/follow_request_controller.ex
	@@ -1,60 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.FollowRequestController do
	use Pleroma.Web, :controller

	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	- plug(:put_view, Pleroma.Web.MastodonAPI.AccountView)
	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(:assign_follower when action != :index)

	action_fallback(:errors)

	plug(OAuthScopesPlug, %{scopes: ["follow", "read:follows"]} when action == :index)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "write:follows"]} when action != :index
	)

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

	@doc "GET /api/v1/follow_requests"
	def index(%{assigns: %{user: followed}} = conn, _params) do
	follow_requests = User.get_follow_requests(followed)

	render(conn, "index.json", for: followed, users: follow_requests, as: :user)
	end

	@doc "POST /api/v1/follow_requests/:id/authorize"
	def authorize(%{assigns: %{user: followed, follower: follower}} = conn, _params) do
	with {:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do
	render(conn, "relationship.json", user: followed, target: follower)
	end
	end

	@doc "POST /api/v1/follow_requests/:id/reject"
	def reject(%{assigns: %{user: followed, follower: follower}} = conn, _params) do
	with {:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
	render(conn, "relationship.json", user: followed, target: follower)
	end
	end

	defp assign_follower(%{params: %{id: id}} = conn, _) do
	case User.get_cached_by_id(id) do
	%User{} = follower -> assign(conn, :follower, follower)
	nil -> Pleroma.Web.MastodonAPI.FallbackController.call(conn, {:error, :not_found}) \|> halt()
	end
	end

	defp errors(conn, {:error, message}) do
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/media_controller.ex b/lib/pleroma/web/mastodon_api/controllers/media_controller.ex
	index d6949ed80..5918b288d 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/media_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/media_controller.ex
	@@ -1,81 +1,80 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.MediaController do
	use Pleroma.Web, :controller

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
	plug(Majic.Plug, [pool: Pleroma.MajicPool] when action in [:create, :create2])
	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	- plug(:put_view, Pleroma.Web.MastodonAPI.StatusView)

	plug(OAuthScopesPlug, %{scopes: ["read:media"]} when action == :show)
	plug(OAuthScopesPlug, %{scopes: ["write:media"]} when action != :show)

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

	@doc "POST /api/v1/media"
	def create(%{assigns: %{user: user}, body_params: %{file: file} = data} = conn, _) do
	with {:ok, object} <-
	ActivityPub.upload(
	file,
	actor: User.ap_id(user),
	description: Map.get(data, :description)
	) do
	attachment_data = Map.put(object.data, "id", object.id)

	render(conn, "attachment.json", %{attachment: attachment_data})
	end
	end

	def create(_conn, _data), do: {:error, :bad_request}

	@doc "POST /api/v2/media"
	def create2(%{assigns: %{user: user}, body_params: %{file: file} = data} = conn, _) do
	with {:ok, object} <-
	ActivityPub.upload(
	file,
	actor: User.ap_id(user),
	description: Map.get(data, :description)
	) do
	attachment_data = Map.put(object.data, "id", object.id)

	conn
	\|> put_status(202)
	\|> render("attachment.json", %{attachment: attachment_data})
	end
	end

	def create2(_conn, _data), do: {:error, :bad_request}

	@doc "PUT /api/v1/media/:id"
	def update(%{assigns: %{user: user}, body_params: %{description: description}} = conn, %{id: id}) do
	with %Object{} = object <- Object.get_by_id(id),
	:ok <- Object.authorize_access(object, user),
	{:ok, %Object{data: data}} <- Object.update_data(object, %{"name" => description}) do
	attachment_data = Map.put(data, "id", object.id)

	render(conn, "attachment.json", %{attachment: attachment_data})
	end
	end

	def update(conn, data), do: show(conn, data)

	@doc "GET /api/v1/media/:id"
	def show(%{assigns: %{user: user}} = conn, %{id: id}) do
	with %Object{data: data, id: object_id} = object <- Object.get_by_id(id),
	:ok <- Object.authorize_access(object, user) do
	attachment_data = Map.put(data, "id", object_id)

	render(conn, "attachment.json", %{attachment: attachment_data})
	end
	end

	def show(_conn, _data), do: {:error, :bad_request}
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex b/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
	index cef299aa4..3f5849777 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
	@@ -1,218 +1,216 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.TimelineController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [add_link_headers: 2, add_link_headers: 3]

	alias Pleroma.Config
	alias Pleroma.Pagination
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlug
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.RateLimiter

	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(:skip_plug, EnsurePublicOrAuthenticatedPlug when action in [:public, :hashtag])

	# TODO: Replace with a macro when there is a Phoenix release with the following commit in it:
	# https://github.com/phoenixframework/phoenix/commit/2e8c63c01fec4dde5467dbbbf9705ff9e780735e

	plug(RateLimiter, [name: :timeline, bucket_name: :direct_timeline] when action == :direct)
	plug(RateLimiter, [name: :timeline, bucket_name: :public_timeline] when action == :public)
	plug(RateLimiter, [name: :timeline, bucket_name: :home_timeline] when action == :home)
	plug(RateLimiter, [name: :timeline, bucket_name: :hashtag_timeline] when action == :hashtag)
	plug(RateLimiter, [name: :timeline, bucket_name: :list_timeline] when action == :list)

	plug(OAuthScopesPlug, %{scopes: ["read:statuses"]} when action in [:home, :direct])
	plug(OAuthScopesPlug, %{scopes: ["read:lists"]} when action == :list)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:statuses"], fallback: :proceed_unauthenticated}
	when action in [:public, :hashtag]
	)

	- plug(:put_view, Pleroma.Web.MastodonAPI.StatusView)
	-
	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.TimelineOperation

	# GET /api/v1/timelines/home
	def home(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:local_only, params[:local])
	\|> Map.delete(:local)

	activities =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(activities)
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	end

	# GET /api/v1/timelines/direct
	def direct(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put(:type, "Create")
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:visibility, "direct")

	activities =
	[user.ap_id]
	\|> ActivityPub.fetch_activities_query(params)
	\|> Pagination.fetch_paginated(params)

	conn
	\|> add_link_headers(activities)
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity
	)
	end

	defp restrict_unauthenticated?(true = _local_only) do
	Config.restrict_unauthenticated_access?(:timelines, :local)
	end

	defp restrict_unauthenticated?(_) do
	Config.restrict_unauthenticated_access?(:timelines, :federated)
	end

	# GET /api/v1/timelines/public
	def public(%{assigns: %{user: user}} = conn, params) do
	local_only = params[:local]

	if is_nil(user) and restrict_unauthenticated?(local_only) do
	fail_on_bad_auth(conn)
	else
	activities =
	params
	\|> Map.put(:type, ["Create"])
	\|> Map.put(:local_only, local_only)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:instance, params[:instance])
	\|> ActivityPub.fetch_public_activities()

	conn
	\|> add_link_headers(activities, %{"local" => local_only})
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	end
	end

	defp fail_on_bad_auth(conn) do
	render_error(conn, :unauthorized, "authorization required for timeline view")
	end

	defp hashtag_fetching(params, user, local_only) do
	tags =
	[params[:tag], params[:any]]
	\|> List.flatten()
	\|> Enum.uniq()
	\|> Enum.reject(&is_nil/1)
	\|> Enum.map(&String.downcase/1)

	tag_all =
	params
	\|> Map.get(:all, [])
	\|> Enum.map(&String.downcase/1)

	tag_reject =
	params
	\|> Map.get(:none, [])
	\|> Enum.map(&String.downcase/1)

	_activities =
	params
	\|> Map.put(:type, "Create")
	\|> Map.put(:local_only, local_only)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:tag, tags)
	\|> Map.put(:tag_all, tag_all)
	\|> Map.put(:tag_reject, tag_reject)
	\|> ActivityPub.fetch_public_activities()
	end

	# GET /api/v1/timelines/tag/:tag
	def hashtag(%{assigns: %{user: user}} = conn, params) do
	local_only = params[:local]

	if is_nil(user) and restrict_unauthenticated?(local_only) do
	fail_on_bad_auth(conn)
	else
	activities = hashtag_fetching(params, user, local_only)

	conn
	\|> add_link_headers(activities, %{"local" => local_only})
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	end
	end

	# GET /api/v1/timelines/list/:list_id
	def list(%{assigns: %{user: user}} = conn, %{list_id: id} = params) do
	with %Pleroma.List{title: _title, following: following} <- Pleroma.List.get(id, user) do
	params =
	params
	\|> Map.put(:type, "Create")
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:local_only, params[:local])

	# we must filter the following list for the user to avoid leaking statuses the user
	# does not actually have permission to see (for more info, peruse security issue #270).

	user_following = User.following(user)

	activities =
	following
	\|> Enum.filter(fn x -> x in user_following end)
	\|> ActivityPub.fetch_activities_bounded(following, params)
	\|> Enum.reverse()

	render(conn, "index.json",
	activities: activities,
	for: user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	else
	_e -> render_error(conn, :forbidden, "Error.")
	end
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/follow_request_view.ex b/lib/pleroma/web/mastodon_api/views/follow_request_view.ex
	new file mode 100644
	index 000000000..4c7d9fc65
	--- /dev/null
	+++ b/lib/pleroma/web/mastodon_api/views/follow_request_view.ex
	@@ -0,0 +1,10 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.MastodonAPI.FollowRequestView do
	+ use Pleroma.Web, :view
	+ alias Pleroma.Web.MastodonAPI
	+
	+ def render(view, opts), do: MastodonAPI.AccountView.render(view, opts)
	+end
	diff --git a/lib/pleroma/web/mastodon_api/views/media_view.ex b/lib/pleroma/web/mastodon_api/views/media_view.ex
	new file mode 100644
	index 000000000..cf521887e
	--- /dev/null
	+++ b/lib/pleroma/web/mastodon_api/views/media_view.ex
	@@ -0,0 +1,10 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.MastodonAPI.MediaView do
	+ use Pleroma.Web, :view
	+ alias Pleroma.Web.MastodonAPI
	+
	+ def render(view, opts), do: MastodonAPI.StatusView.render(view, opts)
	+end
	diff --git a/lib/pleroma/web/mastodon_api/views/timeline_view.ex b/lib/pleroma/web/mastodon_api/views/timeline_view.ex
	new file mode 100644
	index 000000000..91226d78e
	--- /dev/null
	+++ b/lib/pleroma/web/mastodon_api/views/timeline_view.ex
	@@ -0,0 +1,10 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.MastodonAPI.TimelineView do
	+ use Pleroma.Web, :view
	+ alias Pleroma.Web.MastodonAPI
	+
	+ def render(view, opts), do: MastodonAPI.StatusView.render(view, opts)
	+end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/account_controller.ex b/lib/pleroma/web/pleroma_api/controllers/account_controller.ex
	index 165afd3b4..6e01c5497 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/account_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/account_controller.ex
	@@ -1,115 +1,114 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.AccountController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [json_response: 3, add_link_headers: 2, assign_account_by_id: 2]

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlug
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.RateLimiter

	require Pleroma.Constants

	plug(
	Majic.Plug,
	[pool: Pleroma.MajicPool] when action in [:update_avatar, :update_background, :update_banner]
	)

	plug(
	OpenApiSpex.Plug.PutApiSpec,
	[module: Pleroma.Web.ApiSpec] when action == :confirmation_resend
	)

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	:skip_plug,
	[OAuthScopesPlug, EnsurePublicOrAuthenticatedPlug] when action == :confirmation_resend
	)

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

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:favourites"], fallback: :proceed_unauthenticated} when action == :favourites
	)

	plug(RateLimiter, [name: :account_confirmation_resend] when action == :confirmation_resend)

	plug(:assign_account_by_id when action in [:favourites, :subscribe, :unsubscribe])
	- plug(:put_view, Pleroma.Web.MastodonAPI.AccountView)

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

	@doc "POST /api/v1/pleroma/accounts/confirmation_resend"
	def confirmation_resend(conn, params) do
	nickname_or_email = params[:email] \|\| params[:nickname]

	with %User{} = user <- User.get_by_nickname_or_email(nickname_or_email),
	{:ok, _} <- User.maybe_send_confirmation_email(user) do
	json_response(conn, :no_content, "")
	end
	end

	@doc "GET /api/v1/pleroma/accounts/:id/favourites"
	def favourites(%{assigns: %{account: %{hide_favorites: true}}} = conn, _params) do
	render_error(conn, :forbidden, "Can't get favorites")
	end

	def favourites(%{assigns: %{user: for_user, account: user}} = conn, params) do
	params =
	params
	\|> Map.put(:type, "Create")
	\|> Map.put(:favorited_by, user.ap_id)
	\|> Map.put(:blocking_user, for_user)

	recipients =
	if for_user do
	[Pleroma.Constants.as_public()] ++ [for_user.ap_id \| User.following(for_user)]
	else
	[Pleroma.Constants.as_public()]
	end

	activities =
	recipients
	\|> ActivityPub.fetch_activities(params)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(activities)
	\|> put_view(StatusView)
	\|> render("index.json",
	activities: activities,
	for: for_user,
	as: :activity
	)
	end

	@doc "POST /api/v1/pleroma/accounts/:id/subscribe"
	def subscribe(%{assigns: %{user: user, account: subscription_target}} = conn, _params) do
	with {:ok, _subscription} <- User.subscribe(user, subscription_target) do
	render(conn, "relationship.json", user: user, target: subscription_target)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/pleroma/accounts/:id/unsubscribe"
	def unsubscribe(%{assigns: %{user: user, account: subscription_target}} = conn, _params) do
	with {:ok, _subscription} <- User.unsubscribe(user, subscription_target) do
	render(conn, "relationship.json", user: user, target: subscription_target)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/conversation_controller.ex b/lib/pleroma/web/pleroma_api/controllers/conversation_controller.ex
	index d285e4907..be2f4617d 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/conversation_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/conversation_controller.ex
	@@ -1,94 +1,93 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 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.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	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.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/views/account_view.ex b/lib/pleroma/web/pleroma_api/views/account_view.ex
	new file mode 100644
	index 000000000..28941f471
	--- /dev/null
	+++ b/lib/pleroma/web/pleroma_api/views/account_view.ex
	@@ -0,0 +1,10 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.PleromaAPI.AccountView do
	+ use Pleroma.Web, :view
	+ alias Pleroma.Web.MastodonAPI
	+
	+ def render(view, opts), do: MastodonAPI.AccountView.render(view, opts)
	+end
	diff --git a/lib/pleroma/web/pleroma_api/views/conversation_view.ex b/lib/pleroma/web/pleroma_api/views/conversation_view.ex
	new file mode 100644
	index 000000000..173006360
	--- /dev/null
	+++ b/lib/pleroma/web/pleroma_api/views/conversation_view.ex
	@@ -0,0 +1,10 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.PleromaAPI.ConversationView do
	+ use Pleroma.Web, :view
	+ alias Pleroma.Web.MastodonAPI
	+
	+ def render(view, opts), do: MastodonAPI.ConversationView.render(view, opts)
	+end
	diff --git a/lib/pleroma/web/static_fe/static_fe_controller.ex b/lib/pleroma/web/static_fe/static_fe_controller.ex
	index fe485d10d..50f0927a3 100644
	--- a/lib/pleroma/web/static_fe/static_fe_controller.ex
	+++ b/lib/pleroma/web/static_fe/static_fe_controller.ex
	@@ -1,181 +1,180 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.StaticFE.StaticFEController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Metadata
	alias Pleroma.Web.Router.Helpers

	plug(:put_layout, :static_fe)
	- plug(:put_view, Pleroma.Web.StaticFE.StaticFEView)
	plug(:assign_id)

	@page_keys ["max_id", "min_id", "limit", "since_id", "order"]

	@doc "Renders requested local public activity or public activities of requested user"
	def show(%{assigns: %{notice_id: notice_id}} = conn, _params) do
	with %Activity{local: true} = activity <-
	Activity.get_by_id_with_object(notice_id),
	true <- Visibility.is_public?(activity.object),
	{_, true} <- {:visible?, Visibility.visible_for_user?(activity, _reading_user = nil)},
	%User{} = user <- User.get_by_ap_id(activity.object.data["actor"]) do
	meta = Metadata.build_tags(%{activity_id: notice_id, object: activity.object, user: user})

	timeline =
	activity.object.data["context"]
	\|> ActivityPub.fetch_activities_for_context(%{})
	\|> Enum.reverse()
	\|> Enum.map(&represent(&1, &1.object.id == activity.object.id))

	render(conn, "conversation.html", %{activities: timeline, meta: meta})
	else
	%Activity{object: %Object{data: data}} ->
	conn
	\|> put_status(:found)
	\|> redirect(external: data["url"] \|\| data["external_url"] \|\| data["id"])

	_ ->
	not_found(conn, "Post not found.")
	end
	end

	def show(%{assigns: %{username_or_id: username_or_id}} = conn, params) do
	with {_, %User{local: true} = user} <-
	{:fetch_user, User.get_cached_by_nickname_or_id(username_or_id)},
	{_, :visible} <- {:visibility, User.visible_for(user, _reading_user = nil)} do
	meta = Metadata.build_tags(%{user: user})

	params =
	params
	\|> Map.take(@page_keys)
	\|> Map.new(fn {k, v} -> {String.to_existing_atom(k), v} end)

	timeline =
	user
	\|> ActivityPub.fetch_user_activities(_reading_user = nil, params)
	\|> Enum.map(&represent/1)

	prev_page_id =
	(params["min_id"] \|\| params["max_id"]) &&
	List.first(timeline) && List.first(timeline).id

	next_page_id = List.last(timeline) && List.last(timeline).id

	render(conn, "profile.html", %{
	user: User.sanitize_html(user),
	timeline: timeline,
	prev_page_id: prev_page_id,
	next_page_id: next_page_id,
	meta: meta
	})
	else
	_ ->
	not_found(conn, "User not found.")
	end
	end

	def show(%{assigns: %{object_id: _}} = conn, _params) do
	url = Helpers.url(conn) <> conn.request_path

	case Activity.get_create_by_object_ap_id_with_object(url) do
	%Activity{} = activity ->
	to = Helpers.o_status_path(Pleroma.Web.Endpoint, :notice, activity)
	redirect(conn, to: to)

	_ ->
	not_found(conn, "Post not found.")
	end
	end

	def show(%{assigns: %{activity_id: _}} = conn, _params) do
	url = Helpers.url(conn) <> conn.request_path

	case Activity.get_by_ap_id(url) do
	%Activity{} = activity ->
	to = Helpers.o_status_path(Pleroma.Web.Endpoint, :notice, activity)
	redirect(conn, to: to)

	_ ->
	not_found(conn, "Post not found.")
	end
	end

	defp get_title(%Object{data: %{"name" => name}}) when is_binary(name),
	do: name

	defp get_title(%Object{data: %{"summary" => summary}}) when is_binary(summary),
	do: summary

	defp get_title(_), do: nil

	defp not_found(conn, message) do
	conn
	\|> put_status(404)
	\|> render("error.html", %{message: message, meta: ""})
	end

	defp get_counts(%Activity{} = activity) do
	%Object{data: data} = Object.normalize(activity, fetch: false)

	%{
	likes: data["like_count"] \|\| 0,
	replies: data["repliesCount"] \|\| 0,
	announces: data["announcement_count"] \|\| 0
	}
	end

	defp represent(%Activity{} = activity), do: represent(activity, false)

	defp represent(%Activity{object: %Object{data: data}} = activity, selected) do
	{:ok, user} = User.get_or_fetch(activity.object.data["actor"])

	link =
	case user.local do
	true -> Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	_ -> data["url"] \|\| data["external_url"] \|\| data["id"]
	end

	content =
	if data["content"] do
	data["content"]
	\|> Pleroma.HTML.filter_tags()
	\|> Pleroma.Emoji.Formatter.emojify(Map.get(data, "emoji", %{}))
	else
	nil
	end

	%{
	user: User.sanitize_html(user),
	title: get_title(activity.object),
	content: content,
	attachment: data["attachment"],
	link: link,
	published: data["published"],
	sensitive: data["sensitive"],
	selected: selected,
	counts: get_counts(activity),
	id: activity.id
	}
	end

	defp assign_id(%{path_info: ["notice", notice_id]} = conn, _opts),
	do: assign(conn, :notice_id, notice_id)

	defp assign_id(%{path_info: ["users", user_id]} = conn, _opts),
	do: assign(conn, :username_or_id, user_id)

	defp assign_id(%{path_info: ["objects", object_id]} = conn, _opts),
	do: assign(conn, :object_id, object_id)

	defp assign_id(%{path_info: ["activities", activity_id]} = conn, _opts),
	do: assign(conn, :activity_id, activity_id)

	defp assign_id(conn, _opts), do: conn
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 9, 8:59 AM (1 d, 9 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1722677
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions