Merge branch 'openapi/filters' into 'develop'

Add OpenAPI spec for FilterController

See merge request pleroma/pleroma!2382
This commit is contained in:
lain 2020-05-06 08:51:10 +00:00
commit 957172a307
6 changed files with 282 additions and 51 deletions

View file

@ -89,11 +89,10 @@ defmodule Pleroma.Filter do
|> Repo.delete() |> Repo.delete()
end end
def update(%Pleroma.Filter{} = filter) do def update(%Pleroma.Filter{} = filter, params) do
destination = Map.from_struct(filter) filter
|> cast(params, [:phrase, :context, :hide, :expires_at, :whole_word])
Pleroma.Filter.get(filter.filter_id, %{id: filter.user_id}) |> validate_required([:phrase, :context])
|> cast(destination, [:phrase, :context, :hide, :expires_at, :whole_word])
|> Repo.update() |> Repo.update()
end end
end end

View file

@ -0,0 +1,227 @@
# 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.FilterOperation do
alias OpenApiSpex.Operation
alias OpenApiSpex.Schema
alias Pleroma.Web.ApiSpec.Helpers
def open_api_operation(action) do
operation = String.to_existing_atom("#{action}_operation")
apply(__MODULE__, operation, [])
end
def index_operation do
%Operation{
tags: ["apps"],
summary: "View all filters",
operationId: "FilterController.index",
security: [%{"oAuth" => ["read:filters"]}],
responses: %{
200 => Operation.response("Filters", "application/json", array_of_filters())
}
}
end
def create_operation do
%Operation{
tags: ["apps"],
summary: "Create a filter",
operationId: "FilterController.create",
requestBody: Helpers.request_body("Parameters", create_request(), required: true),
security: [%{"oAuth" => ["write:filters"]}],
responses: %{200 => Operation.response("Filter", "application/json", filter())}
}
end
def show_operation do
%Operation{
tags: ["apps"],
summary: "View all filters",
parameters: [id_param()],
operationId: "FilterController.show",
security: [%{"oAuth" => ["read:filters"]}],
responses: %{
200 => Operation.response("Filter", "application/json", filter())
}
}
end
def update_operation do
%Operation{
tags: ["apps"],
summary: "Update a filter",
parameters: [id_param()],
operationId: "FilterController.update",
requestBody: Helpers.request_body("Parameters", update_request(), required: true),
security: [%{"oAuth" => ["write:filters"]}],
responses: %{
200 => Operation.response("Filter", "application/json", filter())
}
}
end
def delete_operation do
%Operation{
tags: ["apps"],
summary: "Remove a filter",
parameters: [id_param()],
operationId: "FilterController.delete",
security: [%{"oAuth" => ["write:filters"]}],
responses: %{
200 =>
Operation.response("Filter", "application/json", %Schema{
type: :object,
description: "Empty object"
})
}
}
end
defp id_param do
Operation.parameter(:id, :path, :string, "Filter ID", example: "123", required: true)
end
defp filter do
%Schema{
title: "Filter",
type: :object,
properties: %{
id: %Schema{type: :string},
phrase: %Schema{type: :string, description: "The text to be filtered"},
context: %Schema{
type: :array,
items: %Schema{type: :string, enum: ["home", "notifications", "public", "thread"]},
description: "The contexts in which the filter should be applied."
},
expires_at: %Schema{
type: :string,
format: :"date-time",
description:
"When the filter should no longer be applied. String (ISO 8601 Datetime), or null if the filter does not expire.",
nullable: true
},
irreversible: %Schema{
type: :boolean,
description:
"Should matching entities in home and notifications be dropped by the server?"
},
whole_word: %Schema{
type: :boolean,
description: "Should the filter consider word boundaries?"
}
},
example: %{
"id" => "5580",
"phrase" => "@twitter.com",
"context" => [
"home",
"notifications",
"public",
"thread"
],
"whole_word" => false,
"expires_at" => nil,
"irreversible" => true
}
}
end
defp array_of_filters do
%Schema{
title: "ArrayOfFilters",
description: "Array of Filters",
type: :array,
items: filter(),
example: [
%{
"id" => "5580",
"phrase" => "@twitter.com",
"context" => [
"home",
"notifications",
"public",
"thread"
],
"whole_word" => false,
"expires_at" => nil,
"irreversible" => true
},
%{
"id" => "6191",
"phrase" => ":eurovision2019:",
"context" => [
"home"
],
"whole_word" => true,
"expires_at" => "2019-05-21T13:47:31.333Z",
"irreversible" => false
}
]
}
end
defp create_request do
%Schema{
title: "FilterCreateRequest",
allOf: [
update_request(),
%Schema{
type: :object,
properties: %{
irreversible: %Schema{
type: :bolean,
description:
"Should the server irreversibly drop matching entities from home and notifications?",
default: false
}
}
}
],
example: %{
"phrase" => "knights",
"context" => ["home"]
}
}
end
defp update_request do
%Schema{
title: "FilterUpdateRequest",
type: :object,
properties: %{
phrase: %Schema{type: :string, description: "The text to be filtered"},
context: %Schema{
type: :array,
items: %Schema{type: :string, enum: ["home", "notifications", "public", "thread"]},
description:
"Array of enumerable strings `home`, `notifications`, `public`, `thread`. At least one context must be specified."
},
irreversible: %Schema{
type: :bolean,
description:
"Should the server irreversibly drop matching entities from home and notifications?"
},
whole_word: %Schema{
type: :bolean,
description: "Consider word boundaries?",
default: true
}
# TODO: probably should implement filter expiration
# expires_in: %Schema{
# type: :string,
# format: :"date-time",
# description:
# "ISO 8601 Datetime for when the filter expires. Otherwise,
# null for a filter that doesn't expire."
# }
},
required: [:phrase, :context],
example: %{
"phrase" => "knights",
"context" => ["home"]
}
}
end
end

View file

@ -10,6 +10,7 @@ defmodule Pleroma.Web.MastodonAPI.FilterController do
@oauth_read_actions [:show, :index] @oauth_read_actions [:show, :index]
plug(Pleroma.Web.ApiSpec.CastAndValidate)
plug(OAuthScopesPlug, %{scopes: ["read:filters"]} when action in @oauth_read_actions) plug(OAuthScopesPlug, %{scopes: ["read:filters"]} when action in @oauth_read_actions)
plug( plug(
@ -17,60 +18,60 @@ defmodule Pleroma.Web.MastodonAPI.FilterController do
%{scopes: ["write:filters"]} when action not in @oauth_read_actions %{scopes: ["write:filters"]} when action not in @oauth_read_actions
) )
defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.FilterOperation
@doc "GET /api/v1/filters" @doc "GET /api/v1/filters"
def index(%{assigns: %{user: user}} = conn, _) do def index(%{assigns: %{user: user}} = conn, _) do
filters = Filter.get_filters(user) filters = Filter.get_filters(user)
render(conn, "filters.json", filters: filters) render(conn, "index.json", filters: filters)
end end
@doc "POST /api/v1/filters" @doc "POST /api/v1/filters"
def create( def create(%{assigns: %{user: user}, body_params: params} = conn, _) do
%{assigns: %{user: user}} = conn,
%{"phrase" => phrase, "context" => context} = params
) do
query = %Filter{ query = %Filter{
user_id: user.id, user_id: user.id,
phrase: phrase, phrase: params.phrase,
context: context, context: params.context,
hide: Map.get(params, "irreversible", false), hide: params.irreversible,
whole_word: Map.get(params, "boolean", true) whole_word: params.whole_word
# expires_at # TODO: support `expires_in` parameter (as in Mastodon API)
} }
{:ok, response} = Filter.create(query) {:ok, response} = Filter.create(query)
render(conn, "filter.json", filter: response) render(conn, "show.json", filter: response)
end end
@doc "GET /api/v1/filters/:id" @doc "GET /api/v1/filters/:id"
def show(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do def show(%{assigns: %{user: user}} = conn, %{id: filter_id}) do
filter = Filter.get(filter_id, user) filter = Filter.get(filter_id, user)
render(conn, "filter.json", filter: filter) render(conn, "show.json", filter: filter)
end end
@doc "PUT /api/v1/filters/:id" @doc "PUT /api/v1/filters/:id"
def update( def update(
%{assigns: %{user: user}} = conn, %{assigns: %{user: user}, body_params: params} = conn,
%{"phrase" => phrase, "context" => context, "id" => filter_id} = params %{id: filter_id}
) do ) do
query = %Filter{ params =
user_id: user.id, params
filter_id: filter_id, |> Map.delete(:irreversible)
phrase: phrase, |> Map.put(:hide, params[:irreversible])
context: context, |> Enum.reject(fn {_key, value} -> is_nil(value) end)
hide: Map.get(params, "irreversible", nil), |> Map.new()
whole_word: Map.get(params, "boolean", true)
# expires_at
}
{:ok, response} = Filter.update(query) # TODO: support `expires_in` parameter (as in Mastodon API)
render(conn, "filter.json", filter: response)
with %Filter{} = filter <- Filter.get(filter_id, user),
{:ok, %Filter{} = filter} <- Filter.update(filter, params) do
render(conn, "show.json", filter: filter)
end
end end
@doc "DELETE /api/v1/filters/:id" @doc "DELETE /api/v1/filters/:id"
def delete(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do def delete(%{assigns: %{user: user}} = conn, %{id: filter_id}) do
query = %Filter{ query = %Filter{
user_id: user.id, user_id: user.id,
filter_id: filter_id filter_id: filter_id

View file

@ -7,11 +7,11 @@ defmodule Pleroma.Web.MastodonAPI.FilterView do
alias Pleroma.Web.CommonAPI.Utils alias Pleroma.Web.CommonAPI.Utils
alias Pleroma.Web.MastodonAPI.FilterView alias Pleroma.Web.MastodonAPI.FilterView
def render("filters.json", %{filters: filters} = opts) do def render("index.json", %{filters: filters}) do
render_many(filters, FilterView, "filter.json", opts) render_many(filters, FilterView, "show.json")
end end
def render("filter.json", %{filter: filter}) do def render("show.json", %{filter: filter}) do
expires_at = expires_at =
if filter.expires_at do if filter.expires_at do
Utils.to_masto_date(filter.expires_at) Utils.to_masto_date(filter.expires_at)

View file

@ -141,17 +141,15 @@ defmodule Pleroma.FilterTest do
context: ["home"] context: ["home"]
} }
query_two = %Pleroma.Filter{ changes = %{
user_id: user.id,
filter_id: 1,
phrase: "who", phrase: "who",
context: ["home", "timeline"] context: ["home", "timeline"]
} }
{:ok, filter_one} = Pleroma.Filter.create(query_one) {:ok, filter_one} = Pleroma.Filter.create(query_one)
{:ok, filter_two} = Pleroma.Filter.update(query_two) {:ok, filter_two} = Pleroma.Filter.update(filter_one, changes)
assert filter_one != filter_two assert filter_one != filter_two
assert filter_two.phrase == query_two.phrase assert filter_two.phrase == changes.phrase
assert filter_two.context == query_two.context assert filter_two.context == changes.context
end end
end end

View file

@ -15,9 +15,12 @@ defmodule Pleroma.Web.MastodonAPI.FilterControllerTest do
context: ["home"] context: ["home"]
} }
conn = post(conn, "/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context}) conn =
conn
|> put_req_header("content-type", "application/json")
|> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
assert response = json_response(conn, 200) assert response = json_response_and_validate_schema(conn, 200)
assert response["phrase"] == filter.phrase assert response["phrase"] == filter.phrase
assert response["context"] == filter.context assert response["context"] == filter.context
assert response["irreversible"] == false assert response["irreversible"] == false
@ -48,12 +51,12 @@ defmodule Pleroma.Web.MastodonAPI.FilterControllerTest do
response = response =
conn conn
|> get("/api/v1/filters") |> get("/api/v1/filters")
|> json_response(200) |> json_response_and_validate_schema(200)
assert response == assert response ==
render_json( render_json(
FilterView, FilterView,
"filters.json", "index.json",
filters: [filter_two, filter_one] filters: [filter_two, filter_one]
) )
end end
@ -72,7 +75,7 @@ defmodule Pleroma.Web.MastodonAPI.FilterControllerTest do
conn = get(conn, "/api/v1/filters/#{filter.filter_id}") conn = get(conn, "/api/v1/filters/#{filter.filter_id}")
assert _response = json_response(conn, 200) assert response = json_response_and_validate_schema(conn, 200)
end end
test "update a filter" do test "update a filter" do
@ -82,7 +85,8 @@ defmodule Pleroma.Web.MastodonAPI.FilterControllerTest do
user_id: user.id, user_id: user.id,
filter_id: 2, filter_id: 2,
phrase: "knight", phrase: "knight",
context: ["home"] context: ["home"],
hide: true
} }
{:ok, _filter} = Pleroma.Filter.create(query) {:ok, _filter} = Pleroma.Filter.create(query)
@ -93,14 +97,17 @@ defmodule Pleroma.Web.MastodonAPI.FilterControllerTest do
} }
conn = conn =
put(conn, "/api/v1/filters/#{query.filter_id}", %{ conn
|> put_req_header("content-type", "application/json")
|> put("/api/v1/filters/#{query.filter_id}", %{
phrase: new.phrase, phrase: new.phrase,
context: new.context context: new.context
}) })
assert response = json_response(conn, 200) assert response = json_response_and_validate_schema(conn, 200)
assert response["phrase"] == new.phrase assert response["phrase"] == new.phrase
assert response["context"] == new.context assert response["context"] == new.context
assert response["irreversible"] == true
end end
test "delete a filter" do test "delete a filter" do
@ -117,7 +124,6 @@ defmodule Pleroma.Web.MastodonAPI.FilterControllerTest do
conn = delete(conn, "/api/v1/filters/#{filter.filter_id}") conn = delete(conn, "/api/v1/filters/#{filter.filter_id}")
assert response = json_response(conn, 200) assert json_response_and_validate_schema(conn, 200) == %{}
assert response == %{}
end end
end end