No OneTemporary
Actions

Authored By

Unknown

Size

12 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/api_spec/operations/admin/o_auth_app_operation.ex b/lib/pleroma/web/api_spec/operations/admin/o_auth_app_operation.ex
	index 3dbef62cd..5d4306754 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/o_auth_app_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/o_auth_app_operation.ex
	@@ -1,217 +1,219 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.OAuthAppOperation 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 index_operation do
	%Operation{
	summary: "Retrieve a list of OAuth applications",
	tags: ["OAuth application management"],
	operationId: "AdminAPI.OAuthAppController.index",
	security: [%{"oAuth" => ["admin:write"]}],
	parameters: [
	Operation.parameter(:name, :query, %Schema{type: :string}, "App name"),
	Operation.parameter(:client_id, :query, %Schema{type: :string}, "Client ID"),
	Operation.parameter(:page, :query, %Schema{type: :integer, default: 1}, "Page"),
	Operation.parameter(
	:trusted,
	:query,
	%Schema{type: :boolean, default: false},
	"Trusted apps"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 50},
	"Number of apps to return"
	)
	\| admin_api_params()
	],
	responses: %{
	200 =>
	Operation.response("List of apps", "application/json", %Schema{
	type: :object,
	properties: %{
	apps: %Schema{type: :array, items: oauth_app()},
	count: %Schema{type: :integer},
	page_size: %Schema{type: :integer}
	},
	example: %{
	"apps" => [
	%{
	"id" => 1,
	"name" => "App name",
	"client_id" => "yHoDSiWYp5mPV6AfsaVOWjdOyt5PhWRiafi6MRd1lSk",
	"client_secret" => "nLmis486Vqrv2o65eM9mLQx_m_4gH-Q6PcDpGIMl6FY",
	"redirect_uri" => "https://example.com/oauth-callback",
	"website" => "https://example.com",
	"trusted" => true
	}
	],
	"count" => 1,
	"page_size" => 50
	}
	})
	}
	}
	end

	def create_operation do
	%Operation{
	tags: ["OAuth application management"],
	summary: "Create an OAuth application",
	operationId: "AdminAPI.OAuthAppController.create",
	requestBody: request_body("Parameters", create_request()),
	parameters: admin_api_params(),
	security: [%{"oAuth" => ["admin:write"]}],
	responses: %{
	200 => Operation.response("App", "application/json", oauth_app()),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["OAuth application management"],
	summary: "Update OAuth application",
	operationId: "AdminAPI.OAuthAppController.update",
	parameters: [id_param() \| admin_api_params()],
	security: [%{"oAuth" => ["admin:write"]}],
	requestBody: request_body("Parameters", update_request()),
	responses: %{
	200 => Operation.response("App", "application/json", oauth_app()),
	400 =>
	Operation.response("Bad Request", "application/json", %Schema{
	oneOf: [ApiError, %Schema{type: :string}]
	})
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["OAuth application management"],
	summary: "Delete OAuth application",
	operationId: "AdminAPI.OAuthAppController.delete",
	parameters: [id_param() \| admin_api_params()],
	security: [%{"oAuth" => ["admin:write"]}],
	responses: %{
	204 => no_content_response(),
	400 => no_content_response()
	}
	}
	end

	defp create_request do
	%Schema{
	title: "oAuthAppCreateRequest",
	type: :object,
	required: [:name, :redirect_uris],
	properties: %{
	name: %Schema{type: :string, description: "Application Name"},
	scopes: %Schema{type: :array, items: %Schema{type: :string}, description: "oAuth scopes"},
	redirect_uris: %Schema{
	- type: :array, items: %Schema{type: :string},
	+ type: :array,
	+ items: %Schema{type: :string},
	description:
	"Where the user should be redirected after authorization. To display the authorization code to the user instead of redirecting to a web page, use `urn:ietf:wg:oauth:2.0:oob` in this parameter."
	},
	website: %Schema{
	type: :string,
	nullable: true,
	description: "A URL to the homepage of the app"
	},
	trusted: %Schema{
	type: :boolean,
	nullable: true,
	default: false,
	description: "Is the app trusted?"
	}
	},
	example: %{
	"name" => "My App",
	"redirect_uris" => ["https://myapp.com/auth/callback"],
	"website" => "https://myapp.com/",
	"scopes" => ["read", "write"],
	"trusted" => true
	}
	}
	end

	defp update_request do
	%Schema{
	title: "oAuthAppUpdateRequest",
	type: :object,
	properties: %{
	name: %Schema{type: :string, description: "Application Name"},
	scopes: %Schema{type: :array, items: %Schema{type: :string}, description: "oAuth scopes"},
	redirect_uris: %Schema{
	- type: :array, items: %Schema{type: :string},
	+ type: :array,
	+ items: %Schema{type: :string},
	description:
	"Where the user should be redirected after authorization. To display the authorization code to the user instead of redirecting to a web page, use `urn:ietf:wg:oauth:2.0:oob` in this parameter."
	},
	website: %Schema{
	type: :string,
	nullable: true,
	description: "A URL to the homepage of the app"
	},
	trusted: %Schema{
	type: :boolean,
	nullable: true,
	default: false,
	description: "Is the app trusted?"
	}
	},
	example: %{
	"name" => "My App",
	"redirect_uris" => ["https://myapp.com/auth/callback"],
	"website" => "https://myapp.com/",
	"scopes" => ["read", "write"],
	"trusted" => true
	}
	}
	end

	defp oauth_app do
	%Schema{
	title: "oAuthApp",
	type: :object,
	properties: %{
	id: %Schema{type: :integer},
	name: %Schema{type: :string},
	client_id: %Schema{type: :string},
	client_secret: %Schema{type: :string},
	redirect_uri: %Schema{type: :string},
	website: %Schema{type: :string, nullable: true},
	trusted: %Schema{type: :boolean}
	},
	example: %{
	"id" => 123,
	"name" => "My App",
	"client_id" => "TWhM-tNSuncnqN7DBJmoyeLnk6K3iJJ71KKXxgL1hPM",
	"client_secret" => "ZEaFUFmF0umgBX1qKJDjaU99Q31lDkOU8NutzTOoliw",
	"redirect_uri" => "https://myapp.com/oauth-callback",
	"website" => "https://myapp.com/",
	"trusted" => false
	}
	}
	end

	def id_param do
	Operation.parameter(:id, :path, :integer, "App ID",
	example: 1337,
	required: true
	)
	end
	end
	diff --git a/lib/pleroma/web/o_auth/app.ex b/lib/pleroma/web/o_auth/app.ex
	index 7661c2566..f1145d500 100644
	--- a/lib/pleroma/web/o_auth/app.ex
	+++ b/lib/pleroma/web/o_auth/app.ex
	@@ -1,184 +1,184 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.App do
	use Ecto.Schema
	import Ecto.Changeset
	import Ecto.Query
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.OAuth.Token

	@type t :: %__MODULE__{}

	schema "apps" do
	field(:client_name, :string)
	- field(:redirect_uris, :string)
	+ field(:redirect_uris, {:array, :string})
	field(:scopes, {:array, :string}, default: [])
	field(:website, :string)
	field(:client_id, :string)
	field(:client_secret, :string)
	field(:trusted, :boolean, default: false)

	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)

	has_many(:oauth_authorizations, Pleroma.Web.OAuth.Authorization, on_delete: :delete_all)
	has_many(:oauth_tokens, Pleroma.Web.OAuth.Token, on_delete: :delete_all)

	timestamps()
	end

	@spec changeset(t(), map()) :: Ecto.Changeset.t()
	def changeset(struct, params) do
	cast(struct, params, [:client_name, :redirect_uris, :scopes, :website, :trusted, :user_id])
	end

	@spec register_changeset(t(), map()) :: Ecto.Changeset.t()
	def register_changeset(struct, params \\ %{}) do
	changeset =
	struct
	\|> changeset(params)
	\|> validate_required([:client_name, :redirect_uris, :scopes])

	if changeset.valid? do
	changeset
	\|> put_change(
	:client_id,
	:crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false)
	)
	\|> put_change(
	:client_secret,
	:crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false)
	)
	else
	changeset
	end
	end

	@spec create(map()) :: {:ok, t()} \| {:error, Ecto.Changeset.t()}
	def create(params) do
	%__MODULE__{}
	\|> register_changeset(params)
	\|> Repo.insert()
	end

	@spec update(pos_integer(), map()) :: {:ok, t()} \| {:error, Ecto.Changeset.t()} \| nil
	def update(id, params) do
	with %__MODULE__{} = app <- Repo.get(__MODULE__, id) do
	app
	\|> changeset(params)
	\|> Repo.update()
	end
	end

	@doc """
	Gets app by attrs or create new with attrs.
	And updates the scopes if need.
	"""
	@spec get_or_make(map(), list(String.t())) :: {:ok, t()} \| {:error, Ecto.Changeset.t()}
	def get_or_make(attrs, scopes) do
	with %__MODULE__{} = app <- Repo.get_by(__MODULE__, attrs) do
	update_scopes(app, scopes)
	else
	_e ->
	%__MODULE__{}
	\|> register_changeset(Map.put(attrs, :scopes, scopes))
	\|> Repo.insert()
	end
	end

	defp update_scopes(%__MODULE__{} = app, []), do: {:ok, app}
	defp update_scopes(%__MODULE__{scopes: scopes} = app, scopes), do: {:ok, app}

	defp update_scopes(%__MODULE__{} = app, scopes) do
	app
	\|> change(%{scopes: scopes})
	\|> Repo.update()
	end

	@spec search(map()) :: {:ok, [t()], non_neg_integer()}
	def search(params) do
	query = from(a in __MODULE__)

	query =
	if params[:client_name] do
	from(a in query, where: a.client_name == ^params[:client_name])
	else
	query
	end

	query =
	if params[:client_id] do
	from(a in query, where: a.client_id == ^params[:client_id])
	else
	query
	end

	query =
	if Map.has_key?(params, :trusted) do
	from(a in query, where: a.trusted == ^params[:trusted])
	else
	query
	end

	query =
	from(u in query,
	limit: ^params[:page_size],
	offset: ^((params[:page] - 1) * params[:page_size])
	)

	count = Repo.aggregate(__MODULE__, :count, :id)

	{:ok, Repo.all(query), count}
	end

	@spec get_user_apps(User.t()) :: {:ok, [t()], non_neg_integer()}
	def get_user_apps(%User{id: user_id}) do
	from(a in __MODULE__, where: a.user_id == ^user_id)
	\|> Repo.all()
	end

	@spec destroy(pos_integer()) :: {:ok, t()} \| {:error, Ecto.Changeset.t()}
	def destroy(id) do
	with %__MODULE__{} = app <- Repo.get(__MODULE__, id) do
	Repo.delete(app)
	end
	end

	@spec errors(Ecto.Changeset.t()) :: map()
	def errors(changeset) do
	Enum.reduce(changeset.errors, %{}, fn
	{:client_name, {error, _}}, acc ->
	Map.put(acc, :name, error)

	{key, {error, _}}, acc ->
	Map.put(acc, key, error)
	end)
	end

	@spec maybe_update_owner(Token.t()) :: :ok
	def maybe_update_owner(%Token{app_id: app_id, user_id: user_id}) when not is_nil(user_id) do
	__MODULE__.update(app_id, %{user_id: user_id})

	:ok
	end

	def maybe_update_owner(_), do: :ok

	@spec remove_orphans(pos_integer()) :: :ok
	def remove_orphans(limit \\ 100) do
	fifteen_mins_ago = DateTime.add(DateTime.utc_now(), -900, :second)

	Repo.transaction(fn ->
	from(a in __MODULE__,
	where: is_nil(a.user_id) and a.inserted_at < ^fifteen_mins_ago,
	limit: ^limit
	)
	\|> Repo.all()
	\|> Enum.each(&Repo.delete(&1))
	end)

	:ok
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 5:41 AM (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799576
Default Alt Text: (12 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions