Merge branch 'develop' into gitlab-mr-iid-4381
This commit is contained in:
Phantasm
commit
70c79ad512
41 changed files with 2753 additions and 101 deletions
|
|
@ -35,6 +35,7 @@ defmodule Pleroma.Notification do
|
|||
# remember to add a migration to add it to the `notifications_type` enum
|
||||
# as well.
|
||||
field(:type, :string)
|
||||
field(:group_key, :string)
|
||||
belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
|
||||
belongs_to(:activity, Activity, type: FlakeId.Ecto.CompatType)
|
||||
|
||||
|
|
@ -49,7 +50,7 @@ defmodule Pleroma.Notification do
|
|||
|> type_from_activity()
|
||||
|
||||
notification
|
||||
|> changeset(%{type: type})
|
||||
|> changeset(%{type: type, group_key: grouped_notification_key(type, activity)})
|
||||
|> Repo.update()
|
||||
end
|
||||
end
|
||||
|
|
@ -62,6 +63,99 @@ defmodule Pleroma.Notification do
|
|||
|> Repo.aggregate(:count, :id)
|
||||
end
|
||||
|
||||
@groupable_notification_types ~w{favourite follow reblog}
|
||||
@group_bucket_seconds 12 * 60 * 60
|
||||
|
||||
def groupable_notification_types, do: @groupable_notification_types
|
||||
|
||||
def group_notifications(notifications, grouped_types \\ nil) do
|
||||
grouped_types = normalize_grouped_types(grouped_types)
|
||||
|
||||
{group_keys, grouped_notifications} =
|
||||
Enum.reduce(notifications, {[], %{}}, fn notification,
|
||||
{group_keys, grouped_notifications} ->
|
||||
group_key = group_key(notification, grouped_types)
|
||||
|
||||
if Map.has_key?(grouped_notifications, group_key) do
|
||||
{group_keys, Map.update!(grouped_notifications, group_key, &[notification | &1])}
|
||||
else
|
||||
{[group_key | group_keys], Map.put(grouped_notifications, group_key, [notification])}
|
||||
end
|
||||
end)
|
||||
|
||||
group_keys
|
||||
|> Enum.reverse()
|
||||
|> Enum.map(fn group_key ->
|
||||
grouped_notifications
|
||||
|> Map.fetch!(group_key)
|
||||
|> Enum.reverse()
|
||||
end)
|
||||
end
|
||||
|
||||
def group_key(notification, grouped_types \\ nil)
|
||||
|
||||
def group_key(%Notification{} = notification, nil) do
|
||||
group_key(notification, @groupable_notification_types)
|
||||
end
|
||||
|
||||
def group_key(%Notification{type: type, group_key: group_key} = notification, grouped_types) do
|
||||
grouped_types = normalize_grouped_types(grouped_types)
|
||||
|
||||
if type in @groupable_notification_types and type in grouped_types and is_binary(group_key) do
|
||||
group_key
|
||||
else
|
||||
ungrouped_group_key(notification)
|
||||
end
|
||||
end
|
||||
|
||||
def normalize_grouped_types(nil), do: @groupable_notification_types
|
||||
def normalize_grouped_types(types) when is_list(types), do: types
|
||||
def normalize_grouped_types(type), do: [type]
|
||||
|
||||
defp ungrouped_group_key(%Notification{id: id}), do: "ungrouped-#{id}"
|
||||
|
||||
defp grouped_notification_key(type, activity) when type in @groupable_notification_types do
|
||||
with target_id when is_binary(target_id) <- group_target_id(type, activity) do
|
||||
# Mastodon uses Redis to reuse a recent bucket for rolling 12h windows. Pleroma keeps keys
|
||||
# deterministic and self-contained; clients must treat group_key as opaque either way.
|
||||
"#{type}-#{target_id}-#{group_time_bucket(activity)}"
|
||||
end
|
||||
end
|
||||
|
||||
defp grouped_notification_key(_type, _activity), do: nil
|
||||
|
||||
defp group_time_bucket(%Activity{inserted_at: inserted_at}) when not is_nil(inserted_at) do
|
||||
inserted_at
|
||||
|> NaiveDateTime.to_erl()
|
||||
|> :calendar.datetime_to_gregorian_seconds()
|
||||
|> div(@group_bucket_seconds)
|
||||
end
|
||||
|
||||
defp group_time_bucket(_),
|
||||
do: group_time_bucket(%Activity{inserted_at: NaiveDateTime.utc_now()})
|
||||
|
||||
defp group_target_id(type, activity) when type in ["favourite", "reblog"] do
|
||||
with object_id when is_binary(object_id) <- object_id_for(activity),
|
||||
%Activity{id: id} <- Activity.get_create_by_object_ap_id(object_id) do
|
||||
to_string(id)
|
||||
else
|
||||
_ -> nil
|
||||
end
|
||||
end
|
||||
|
||||
defp group_target_id("follow", %{data: %{"object" => ap_id}}) do
|
||||
case User.get_cached_by_ap_id(ap_id) do
|
||||
%User{id: id} -> to_string(id)
|
||||
_ -> nil
|
||||
end
|
||||
end
|
||||
|
||||
defp group_target_id(_, _), do: nil
|
||||
|
||||
defp object_id_for(%{data: %{"object" => %{"id" => id}}}) when is_binary(id), do: id
|
||||
defp object_id_for(%{data: %{"object" => id}}) when is_binary(id), do: id
|
||||
defp object_id_for(_), do: nil
|
||||
|
||||
@notification_types ~w{
|
||||
favourite
|
||||
follow
|
||||
|
|
@ -79,7 +173,7 @@ defmodule Pleroma.Notification do
|
|||
|
||||
def changeset(%Notification{} = notification, attrs) do
|
||||
notification
|
||||
|> cast(attrs, [:seen, :type])
|
||||
|> cast(attrs, [:seen, :type, :group_key])
|
||||
|> validate_inclusion(:type, @notification_types)
|
||||
end
|
||||
|
||||
|
|
@ -458,7 +552,8 @@ defmodule Pleroma.Notification do
|
|||
user_id: user.id,
|
||||
activity: activity,
|
||||
seen: mark_as_read?(activity, user),
|
||||
type: type
|
||||
type: type,
|
||||
group_key: grouped_notification_key(type, activity)
|
||||
})
|
||||
|> Marker.multi_set_last_read_id(user, "notifications")
|
||||
|> Repo.transaction()
|
||||
|
|
|
|||
|
|
@ -1881,11 +1881,15 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
|
|||
end
|
||||
end
|
||||
|
||||
@featured_collection_types ["OrderedCollection", "Collection"]
|
||||
@featured_collection_page_types ["OrderedCollectionPage", "CollectionPage"]
|
||||
@featured_collection_item_types @featured_collection_types ++ @featured_collection_page_types
|
||||
|
||||
def pin_data_from_featured_collection(%{
|
||||
"type" => type,
|
||||
"orderedItems" => objects
|
||||
})
|
||||
when type in ["OrderedCollection", "Collection"] do
|
||||
when type in @featured_collection_item_types do
|
||||
Map.new(objects, fn
|
||||
%{"id" => object_ap_id} -> {object_ap_id, NaiveDateTime.utc_now()}
|
||||
object_ap_id when is_binary(object_ap_id) -> {object_ap_id, NaiveDateTime.utc_now()}
|
||||
|
|
@ -1903,7 +1907,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
|
|||
|
||||
def fetch_and_prepare_featured_from_ap_id(ap_id) do
|
||||
with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id) do
|
||||
{:ok, pin_data_from_featured_collection(data)}
|
||||
{:ok, prepare_featured_collection(data)}
|
||||
else
|
||||
e ->
|
||||
Logger.error("Could not decode featured collection at fetch #{ap_id}, #{inspect(e)}")
|
||||
|
|
@ -1911,6 +1915,34 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
|
|||
end
|
||||
end
|
||||
|
||||
defp prepare_featured_collection(%{"orderedItems" => objects} = data) when is_list(objects) do
|
||||
pin_data_from_featured_collection(data)
|
||||
end
|
||||
|
||||
defp prepare_featured_collection(%{
|
||||
"type" => type,
|
||||
"first" => %{"type" => page_type} = first
|
||||
})
|
||||
when type in @featured_collection_types and page_type in @featured_collection_page_types do
|
||||
pin_data_from_featured_collection(first)
|
||||
end
|
||||
|
||||
defp prepare_featured_collection(%{"type" => type, "first" => first})
|
||||
when type in @featured_collection_types and is_binary(first) do
|
||||
case Fetcher.fetch_and_contain_remote_object_from_id(first) do
|
||||
{:ok, data} ->
|
||||
pin_data_from_featured_collection(data)
|
||||
|
||||
e ->
|
||||
Logger.error("Could not decode featured collection page at fetch #{first}, #{inspect(e)}")
|
||||
%{}
|
||||
end
|
||||
end
|
||||
|
||||
defp prepare_featured_collection(data) do
|
||||
pin_data_from_featured_collection(data)
|
||||
end
|
||||
|
||||
def enqueue_pin_fetches(%{pinned_objects: pins}) do
|
||||
# enqueue a task to fetch all pinned objects
|
||||
Enum.each(pins, fn {ap_id, _} ->
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@
|
|||
# SPDX-License-Identifier: AGPL-3.0-only
|
||||
|
||||
defmodule Pleroma.Web.ApiSpec.NotificationOperation do
|
||||
alias OpenApiSpex.Operation
|
||||
alias OpenApiSpex.Operation
|
||||
alias OpenApiSpex.Schema
|
||||
alias Pleroma.Web.ApiSpec.Schemas.Account
|
||||
|
|
@ -91,6 +90,79 @@ defmodule Pleroma.Web.ApiSpec.NotificationOperation do
|
|||
}
|
||||
end
|
||||
|
||||
def grouped_index_operation do
|
||||
%Operation{
|
||||
tags: ["Notifications"],
|
||||
summary: "Retrieve grouped notifications",
|
||||
description: "Notifications concerning the user, grouped by supported notification types.",
|
||||
operationId: "NotificationController.grouped_index",
|
||||
security: [%{"oAuth" => ["read:notifications"]}],
|
||||
parameters: grouped_notification_params() ++ pagination_params(),
|
||||
responses: %{
|
||||
200 => Operation.response("Grouped notifications", "application/json", grouped_result()),
|
||||
404 => Operation.response("Error", "application/json", ApiError)
|
||||
}
|
||||
}
|
||||
end
|
||||
|
||||
def show_group_operation do
|
||||
%Operation{
|
||||
tags: ["Notifications"],
|
||||
summary: "Retrieve a notification group",
|
||||
operationId: "NotificationController.show_group",
|
||||
security: [%{"oAuth" => ["read:notifications"]}],
|
||||
parameters: [group_key_param()],
|
||||
responses: %{
|
||||
200 => Operation.response("Grouped notifications", "application/json", grouped_result()),
|
||||
404 => Operation.response("Error", "application/json", ApiError)
|
||||
}
|
||||
}
|
||||
end
|
||||
|
||||
def group_accounts_operation do
|
||||
%Operation{
|
||||
tags: ["Notifications"],
|
||||
summary: "Retrieve notification group accounts",
|
||||
operationId: "NotificationController.group_accounts",
|
||||
security: [%{"oAuth" => ["read:notifications"]}],
|
||||
parameters: [group_key_param()],
|
||||
responses: %{
|
||||
200 =>
|
||||
Operation.response("Accounts", "application/json", %Schema{
|
||||
type: :array,
|
||||
items: Account
|
||||
})
|
||||
}
|
||||
}
|
||||
end
|
||||
|
||||
def unread_count_operation do
|
||||
%Operation{
|
||||
tags: ["Notifications"],
|
||||
summary: "Retrieve unread grouped notification count",
|
||||
operationId: "NotificationController.unread_count",
|
||||
security: [%{"oAuth" => ["read:notifications"]}],
|
||||
parameters:
|
||||
grouped_notification_params() ++
|
||||
[
|
||||
Operation.parameter(
|
||||
:limit,
|
||||
:query,
|
||||
%Schema{type: :integer},
|
||||
"Maximum number of notifications to count"
|
||||
)
|
||||
],
|
||||
responses: %{
|
||||
200 =>
|
||||
Operation.response("Unread notification group count", "application/json", %Schema{
|
||||
type: :object,
|
||||
properties: %{count: %Schema{type: :integer}}
|
||||
}),
|
||||
404 => Operation.response("Error", "application/json", ApiError)
|
||||
}
|
||||
}
|
||||
end
|
||||
|
||||
def clear_operation do
|
||||
%Operation{
|
||||
tags: ["Notifications"],
|
||||
|
|
@ -114,6 +186,18 @@ defmodule Pleroma.Web.ApiSpec.NotificationOperation do
|
|||
}
|
||||
end
|
||||
|
||||
def dismiss_group_operation do
|
||||
%Operation{
|
||||
tags: ["Notifications"],
|
||||
summary: "Dismiss a notification group",
|
||||
description: "Clear all notifications in a notification group from the server.",
|
||||
operationId: "NotificationController.dismiss_group",
|
||||
parameters: [group_key_param()],
|
||||
security: [%{"oAuth" => ["write:notifications"]}],
|
||||
responses: %{200 => empty_object_response()}
|
||||
}
|
||||
end
|
||||
|
||||
def dismiss_via_body_operation do
|
||||
%Operation{
|
||||
tags: ["Notifications"],
|
||||
|
|
@ -184,7 +268,7 @@ defmodule Pleroma.Web.ApiSpec.NotificationOperation do
|
|||
},
|
||||
example: %{
|
||||
"id" => "34975861",
|
||||
"group-key" => "ungrouped-34975861",
|
||||
"group_key" => "ungrouped-34975861",
|
||||
"type" => "mention",
|
||||
"created_at" => "2019-11-23T07:49:02.064Z",
|
||||
"account" => Account.schema().example,
|
||||
|
|
@ -194,6 +278,73 @@ defmodule Pleroma.Web.ApiSpec.NotificationOperation do
|
|||
}
|
||||
end
|
||||
|
||||
defp grouped_result do
|
||||
%Schema{
|
||||
title: "GroupedNotificationsResults",
|
||||
type: :object,
|
||||
properties: %{
|
||||
accounts: %Schema{type: :array, items: Account},
|
||||
statuses: %Schema{type: :array, items: Status},
|
||||
notification_groups: %Schema{type: :array, items: notification_group()}
|
||||
},
|
||||
required: [:accounts, :statuses, :notification_groups]
|
||||
}
|
||||
end
|
||||
|
||||
defp notification_group do
|
||||
%Schema{
|
||||
title: "NotificationGroup",
|
||||
type: :object,
|
||||
properties: %{
|
||||
group_key: %Schema{type: :string},
|
||||
notifications_count: %Schema{type: :integer},
|
||||
type: notification_type(),
|
||||
most_recent_notification_id: %Schema{type: :string},
|
||||
page_min_id: %Schema{type: :string, nullable: true},
|
||||
page_max_id: %Schema{type: :string, nullable: true},
|
||||
latest_page_notification_at: %Schema{type: :string, format: :"date-time", nullable: true},
|
||||
sample_account_ids: %Schema{type: :array, items: %Schema{type: :string}},
|
||||
status_id: %Schema{type: :string, nullable: true}
|
||||
},
|
||||
required: [
|
||||
:group_key,
|
||||
:notifications_count,
|
||||
:type,
|
||||
:most_recent_notification_id,
|
||||
:sample_account_ids
|
||||
]
|
||||
}
|
||||
end
|
||||
|
||||
defp grouped_notification_params do
|
||||
[
|
||||
Operation.parameter(
|
||||
:exclude_types,
|
||||
:query,
|
||||
%Schema{type: :array, items: notification_type()},
|
||||
"Array of types to exclude"
|
||||
),
|
||||
Operation.parameter(
|
||||
:account_id,
|
||||
:query,
|
||||
%Schema{type: :string},
|
||||
"Return only notifications received from this account"
|
||||
),
|
||||
Operation.parameter(
|
||||
:types,
|
||||
:query,
|
||||
%Schema{type: :array, items: notification_type()},
|
||||
"Include the notifications for activities with the given types"
|
||||
),
|
||||
Operation.parameter(
|
||||
:grouped_types,
|
||||
:query,
|
||||
%Schema{type: :array, items: notification_type()},
|
||||
"Notification types that may be grouped"
|
||||
)
|
||||
]
|
||||
end
|
||||
|
||||
defp notification_type do
|
||||
%Schema{
|
||||
type: :string,
|
||||
|
|
@ -239,4 +390,11 @@ defmodule Pleroma.Web.ApiSpec.NotificationOperation do
|
|||
required: true
|
||||
)
|
||||
end
|
||||
|
||||
defp group_key_param do
|
||||
Operation.parameter(:group_key, :path, :string, "Notification group key",
|
||||
example: "favourite-123",
|
||||
required: true
|
||||
)
|
||||
end
|
||||
end
|
||||
|
|
|
|||
|
|
@ -55,16 +55,28 @@ defmodule Pleroma.Web.ControllerHelper do
|
|||
|
||||
# TODO: Only fetch the params from open_api_spex when everything is converted
|
||||
@id_keys Pagination.page_keys() -- ["limit", "order"]
|
||||
@id_key_atoms Enum.map(@id_keys, &String.to_atom/1)
|
||||
@drop_id_params_key :drop_id_params
|
||||
defp build_pagination_fields(conn, min_id, max_id, extra_params, order) do
|
||||
drop_id_params? = Map.get(extra_params, @drop_id_params_key, false)
|
||||
extra_params = Map.delete(extra_params, @drop_id_params_key)
|
||||
|
||||
path_param_keys =
|
||||
conn.path_params
|
||||
|> Map.keys()
|
||||
|> Enum.flat_map(&[&1, String.to_existing_atom(&1)])
|
||||
|
||||
params =
|
||||
if Map.has_key?(conn.private, :open_api_spex) do
|
||||
get_in(conn, [Access.key(:private), Access.key(:open_api_spex), Access.key(:params)])
|
||||
else
|
||||
conn.params
|
||||
end
|
||||
|> Map.drop(Map.keys(conn.path_params) |> Enum.map(&String.to_existing_atom/1))
|
||||
|> Map.drop(path_param_keys)
|
||||
|> Map.merge(extra_params)
|
||||
|> Map.drop(@id_keys)
|
||||
# Some OpenApiSpex routes cast cursor params to atoms. Keep the historical default for
|
||||
# existing endpoints, but allow grouped notifications to opt out of stale request cursors.
|
||||
|> Map.drop(@id_keys ++ if(drop_id_params?, do: @id_key_atoms, else: []))
|
||||
|
||||
{{next_id, nid}, {prev_id, pid}} =
|
||||
if order == :desc,
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@ defmodule Pleroma.Web.Endpoint do
|
|||
|
||||
alias Pleroma.Config
|
||||
|
||||
socket("/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler,
|
||||
longpoll: false,
|
||||
plug(Pleroma.Web.MastodonAPI.WebsocketPlug,
|
||||
path: "/api/v1/streaming",
|
||||
websocket: [
|
||||
path: "/",
|
||||
compress: false,
|
||||
|
|
@ -169,8 +169,7 @@ defmodule Pleroma.Web.Endpoint do
|
|||
else: "pleroma_key"
|
||||
|
||||
extra =
|
||||
Config.get([__MODULE__, :extra_cookie_attrs])
|
||||
|> Enum.join(";")
|
||||
Enum.join(Config.get([__MODULE__, :extra_cookie_attrs]), ";")
|
||||
|
||||
# The session will be stored in the cookie and signed,
|
||||
# this means its contents can be read but not tampered with.
|
||||
|
|
|
|||
|
|
@ -5,13 +5,17 @@
|
|||
defmodule Pleroma.Web.MastodonAPI.NotificationController do
|
||||
use Pleroma.Web, :controller
|
||||
|
||||
import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2]
|
||||
import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2, add_link_headers: 3]
|
||||
|
||||
alias Pleroma.Notification
|
||||
alias Pleroma.User
|
||||
alias Pleroma.Web.MastodonAPI.AccountView
|
||||
alias Pleroma.Web.MastodonAPI.MastodonAPI
|
||||
alias Pleroma.Web.Plugs.OAuthScopesPlug
|
||||
|
||||
@oauth_read_actions [:show, :index]
|
||||
# Mastodon's docs currently list write:notifications for group accounts, but the endpoint is
|
||||
# read-only and Mastodon's implementation accepts read:notifications. Prefer least privilege.
|
||||
@oauth_read_actions [:show, :index, :grouped_index, :show_group, :group_accounts, :unread_count]
|
||||
|
||||
plug(Pleroma.Web.ApiSpec.CastAndValidate, replace_params: false)
|
||||
|
||||
|
|
@ -39,7 +43,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationController do
|
|||
|
||||
# GET /api/v1/notifications
|
||||
def index(%{private: %{open_api_spex: %{params: %{account_id: account_id} = params}}} = conn, _) do
|
||||
case Pleroma.User.get_cached_by_id(account_id) do
|
||||
case User.get_cached_by_id(account_id) do
|
||||
%{ap_id: account_ap_id} ->
|
||||
params =
|
||||
params
|
||||
|
|
@ -59,10 +63,108 @@ defmodule Pleroma.Web.MastodonAPI.NotificationController do
|
|||
do_get_notifications(conn, params)
|
||||
end
|
||||
|
||||
# GET /api/v2/notifications
|
||||
def grouped_index(
|
||||
%{private: %{open_api_spex: %{params: %{account_id: account_id} = params}}} = conn,
|
||||
_
|
||||
) do
|
||||
case User.get_cached_by_id(account_id) do
|
||||
%{ap_id: account_ap_id} ->
|
||||
params =
|
||||
params
|
||||
|> Map.delete(:account_id)
|
||||
|> Map.put(:account_ap_id, account_ap_id)
|
||||
|
||||
do_get_grouped_notifications(conn, params)
|
||||
|
||||
_ ->
|
||||
conn
|
||||
|> put_status(:not_found)
|
||||
|> json(%{"error" => "Account is not found"})
|
||||
end
|
||||
end
|
||||
|
||||
def grouped_index(%{private: %{open_api_spex: %{params: params}}} = conn, _) do
|
||||
do_get_grouped_notifications(conn, params)
|
||||
end
|
||||
|
||||
# GET /api/v2/notifications/:group_key
|
||||
def show_group(
|
||||
%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{group_key: group_key}}}} =
|
||||
conn,
|
||||
_
|
||||
) do
|
||||
{notifications, notification_group_counts, notification_group_bounds} =
|
||||
MastodonAPI.get_notification_group_result(user, group_key, %{})
|
||||
|
||||
if Enum.empty?(notifications) do
|
||||
conn
|
||||
|> put_status(:not_found)
|
||||
|> json(%{"error" => "Notification group is not found"})
|
||||
else
|
||||
grouped_types = if String.starts_with?(group_key, "ungrouped-"), do: [], else: nil
|
||||
|
||||
render(conn, "grouped_index.json",
|
||||
notification_groups: [notifications],
|
||||
notification_group_counts: notification_group_counts,
|
||||
notification_group_bounds: notification_group_bounds,
|
||||
for: user,
|
||||
grouped_types: grouped_types,
|
||||
include_page_metadata: false
|
||||
)
|
||||
end
|
||||
end
|
||||
|
||||
# GET /api/v2/notifications/:group_key/accounts
|
||||
def group_accounts(
|
||||
%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{group_key: group_key}}}} =
|
||||
conn,
|
||||
_
|
||||
) do
|
||||
# Mastodon paginates this endpoint in code, but the public docs say it returns accounts of all
|
||||
# notifications in the group and do not document cursor params here. Follow the documented API.
|
||||
users = MastodonAPI.get_notification_group_accounts(user, group_key)
|
||||
|
||||
json(conn, AccountView.render("index.json", %{users: users, for: user}))
|
||||
end
|
||||
|
||||
# GET /api/v2/notifications/unread_count
|
||||
def unread_count(
|
||||
%{private: %{open_api_spex: %{params: %{account_id: account_id} = params}}} = conn,
|
||||
_
|
||||
) do
|
||||
case User.get_cached_by_id(account_id) do
|
||||
%{ap_id: account_ap_id} ->
|
||||
params =
|
||||
params
|
||||
|> Map.delete(:account_id)
|
||||
|> Map.put(:account_ap_id, account_ap_id)
|
||||
|
||||
do_get_unread_group_count(conn, params)
|
||||
|
||||
_ ->
|
||||
conn
|
||||
|> put_status(:not_found)
|
||||
|> json(%{"error" => "Account is not found"})
|
||||
end
|
||||
end
|
||||
|
||||
def unread_count(%{private: %{open_api_spex: %{params: params}}} = conn, _) do
|
||||
do_get_unread_group_count(conn, params)
|
||||
end
|
||||
|
||||
# POST /api/v2/notifications/:group_key/dismiss
|
||||
def dismiss_group(
|
||||
%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{group_key: group_key}}}} =
|
||||
conn,
|
||||
_
|
||||
) do
|
||||
MastodonAPI.dismiss_notification_group(user, group_key)
|
||||
json(conn, %{})
|
||||
end
|
||||
|
||||
defp do_get_notifications(%{assigns: %{user: user}} = conn, params) do
|
||||
params =
|
||||
Map.new(params, fn {k, v} -> {to_string(k), v} end)
|
||||
|> Map.put_new("types", Map.get(params, :include_types, @default_notification_types))
|
||||
params = normalize_notification_params(params)
|
||||
|
||||
notifications = MastodonAPI.get_notifications(user, params)
|
||||
|
||||
|
|
@ -74,6 +176,35 @@ defmodule Pleroma.Web.MastodonAPI.NotificationController do
|
|||
)
|
||||
end
|
||||
|
||||
defp do_get_grouped_notifications(%{assigns: %{user: user}} = conn, params) do
|
||||
params = normalize_notification_params(params)
|
||||
|
||||
{notification_groups, page_notifications, notification_group_counts,
|
||||
notification_group_bounds} =
|
||||
MastodonAPI.get_grouped_notification_page(user, params)
|
||||
|
||||
conn
|
||||
|> add_link_headers(page_notifications, %{drop_id_params: true})
|
||||
|> render("grouped_index.json",
|
||||
notification_groups: notification_groups,
|
||||
notification_group_counts: notification_group_counts,
|
||||
notification_group_bounds: notification_group_bounds,
|
||||
for: user,
|
||||
grouped_types: params["grouped_types"]
|
||||
)
|
||||
end
|
||||
|
||||
defp do_get_unread_group_count(%{assigns: %{user: user}} = conn, params) do
|
||||
params = normalize_notification_params(params)
|
||||
json(conn, %{count: MastodonAPI.unread_notification_group_count(user, params)})
|
||||
end
|
||||
|
||||
defp normalize_notification_params(params) do
|
||||
params
|
||||
|> Map.new(fn {k, v} -> {to_string(k), v} end)
|
||||
|> Map.put_new("types", Map.get(params, :include_types, @default_notification_types))
|
||||
end
|
||||
|
||||
# GET /api/v1/notifications/:id
|
||||
def show(%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
|
||||
with {:ok, notification} <- Notification.get(user, id) do
|
||||
|
|
|
|||
|
|
@ -6,12 +6,16 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPI do
|
|||
import Ecto.Query
|
||||
import Ecto.Changeset
|
||||
|
||||
alias Pleroma.Marker
|
||||
alias Pleroma.Notification
|
||||
alias Pleroma.Pagination
|
||||
alias Pleroma.Repo
|
||||
alias Pleroma.ScheduledActivity
|
||||
alias Pleroma.User
|
||||
alias Pleroma.Web.CommonAPI
|
||||
|
||||
@notification_group_sample_limit 8
|
||||
|
||||
@spec follow(User.t(), User.t(), map) :: {:ok, User.t()} | {:error, String.t()}
|
||||
def follow(follower, followed, params \\ %{}) do
|
||||
result =
|
||||
|
|
@ -61,29 +65,356 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPI do
|
|||
end
|
||||
|
||||
def get_notifications(user, params \\ %{}) do
|
||||
options =
|
||||
cast_params(params) |> Map.update(:include_types, [], fn include_types -> include_types end)
|
||||
user
|
||||
|> notifications_query(params)
|
||||
|> Pagination.fetch_paginated(params)
|
||||
end
|
||||
|
||||
options =
|
||||
if ("pleroma:report" not in options.include_types and
|
||||
User.privileged?(user, :reports_manage_reports)) or
|
||||
User.privileged?(user, :reports_manage_reports) do
|
||||
options
|
||||
else
|
||||
options
|
||||
|> Map.update(:exclude_types, ["pleroma:report"], fn current_exclude_types ->
|
||||
current_exclude_types ++ ["pleroma:report"]
|
||||
end)
|
||||
end
|
||||
def get_grouped_notification_page(user, params \\ %{}) do
|
||||
grouped_types =
|
||||
params
|
||||
|> Map.get("grouped_types")
|
||||
|> Notification.normalize_grouped_types()
|
||||
|
||||
query = notifications_query(user, params)
|
||||
{order, cursor_filters} = group_pagination(params)
|
||||
|
||||
group_rows =
|
||||
query
|
||||
|> notification_group_rows(grouped_types, grouped_limit(params), order, cursor_filters)
|
||||
|
||||
group_rows = if order == :asc, do: Enum.reverse(group_rows), else: group_rows
|
||||
|
||||
page_notifications = representative_notifications(query, group_rows)
|
||||
|
||||
notification_groups =
|
||||
Enum.map(group_rows, ¬ification_group_sample(user, params, &1.group_key))
|
||||
|
||||
{
|
||||
notification_groups,
|
||||
page_notifications,
|
||||
notification_group_counts(group_rows),
|
||||
notification_group_bounds(group_rows)
|
||||
}
|
||||
end
|
||||
|
||||
def get_notification_group_result(user, group_key, params \\ %{}) do
|
||||
notifications = notification_group_sample(user, params, group_key)
|
||||
metadata = notification_group_metadata(user, group_key, params)
|
||||
|
||||
if Enum.empty?(notifications) or is_nil(metadata) do
|
||||
{[], %{}, %{}}
|
||||
else
|
||||
{
|
||||
notifications,
|
||||
%{group_key => metadata.notifications_count},
|
||||
%{group_key => Map.drop(metadata, [:notifications_count])}
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
def get_notification_group(user, group_key, params \\ %{})
|
||||
|
||||
def get_notification_group(user, "ungrouped-" <> notification_id, _params) do
|
||||
case Notification.get(user, notification_id) do
|
||||
{:ok, notification} -> [notification]
|
||||
_ -> []
|
||||
end
|
||||
end
|
||||
|
||||
def get_notification_group(user, group_key, params) do
|
||||
notification_group_sample(user, params, group_key)
|
||||
end
|
||||
|
||||
def get_notification_group_accounts(user, "ungrouped-" <> notification_id) do
|
||||
with {:ok, notification} <- Notification.get(user, notification_id),
|
||||
%User{} = actor <- User.get_cached_by_ap_id(notification.activity.data["actor"]) do
|
||||
[actor]
|
||||
else
|
||||
_ -> []
|
||||
end
|
||||
end
|
||||
|
||||
def get_notification_group_accounts(user, group_key) do
|
||||
user
|
||||
|> notification_group_query(group_key, %{})
|
||||
|> exclude(:preload)
|
||||
|> distinct(true)
|
||||
|> select([user_actor: user_actor], user_actor)
|
||||
|> Repo.all()
|
||||
end
|
||||
|
||||
def dismiss_notification_group(user, "ungrouped-" <> notification_id) do
|
||||
Notification.destroy_multiple(user, [notification_id])
|
||||
end
|
||||
|
||||
def dismiss_notification_group(%User{id: user_id}, group_key) do
|
||||
Notification
|
||||
|> where([n], n.user_id == ^user_id and n.group_key == ^group_key)
|
||||
|> Repo.delete_all()
|
||||
end
|
||||
|
||||
defp group_pagination(params) do
|
||||
cond do
|
||||
min_id = Map.get(params, "min_id") ->
|
||||
cursor_filters = [{:gt, min_id}]
|
||||
|
||||
cursor_filters =
|
||||
case Map.get(params, "max_id") do
|
||||
nil -> cursor_filters
|
||||
max_id -> [{:lt, max_id} | cursor_filters]
|
||||
end
|
||||
|
||||
{:asc, cursor_filters}
|
||||
|
||||
since_id = Map.get(params, "since_id") ->
|
||||
{:desc, [{:gt, since_id}]}
|
||||
|
||||
max_id = Map.get(params, "max_id") ->
|
||||
{:desc, [{:lt, max_id}]}
|
||||
|
||||
true ->
|
||||
{:desc, []}
|
||||
end
|
||||
end
|
||||
|
||||
defp grouped_limit(params) do
|
||||
params
|
||||
|> Map.get("limit", 40)
|
||||
|> parse_limit(40)
|
||||
|> min(80)
|
||||
end
|
||||
|
||||
def unread_notification_group_count(user, params \\ %{}) do
|
||||
grouped_types =
|
||||
params
|
||||
|> Map.get("grouped_types")
|
||||
|> Notification.normalize_grouped_types()
|
||||
|
||||
limit = unread_count_limit(params)
|
||||
|
||||
user
|
||||
|> notifications_query(params)
|
||||
# The grouped API docs define unread by the notifications marker, not by Pleroma's per-row
|
||||
# seen flag used by the v1 unread count. Keep this marker-based for Mastodon clients.
|
||||
|> restrict_after_marker(notification_marker_last_read_id(user))
|
||||
|> notification_group_rows(grouped_types, limit, :desc, [])
|
||||
|> length()
|
||||
end
|
||||
|
||||
defp notification_group_rows(query, grouped_types, group_limit, :desc, cursor_filters) do
|
||||
query
|
||||
|> notification_group_keyed_query(grouped_types)
|
||||
|> group_by([n], n.group_key)
|
||||
|> apply_group_cursor_filters(cursor_filters)
|
||||
|> select([n], %{
|
||||
group_key: n.group_key,
|
||||
representative_id: max(n.id),
|
||||
notifications_count: count(n.id),
|
||||
page_min_id: min(n.id),
|
||||
page_max_id: max(n.id),
|
||||
latest_page_notification_at: max(n.inserted_at)
|
||||
})
|
||||
|> order_by([n], desc: max(n.id))
|
||||
|> limit(^group_limit)
|
||||
|> Repo.all()
|
||||
end
|
||||
|
||||
defp notification_group_rows(query, grouped_types, group_limit, :asc, cursor_filters) do
|
||||
query
|
||||
|> notification_group_keyed_query(grouped_types)
|
||||
|> group_by([n], n.group_key)
|
||||
|> apply_group_cursor_filters(cursor_filters)
|
||||
|> select([n], %{
|
||||
group_key: n.group_key,
|
||||
representative_id: max(n.id),
|
||||
notifications_count: count(n.id),
|
||||
page_min_id: min(n.id),
|
||||
page_max_id: max(n.id),
|
||||
latest_page_notification_at: max(n.inserted_at)
|
||||
})
|
||||
|> order_by([n], asc: max(n.id))
|
||||
|> limit(^group_limit)
|
||||
|> Repo.all()
|
||||
end
|
||||
|
||||
defp apply_group_cursor_filters(query, []), do: query
|
||||
|
||||
defp apply_group_cursor_filters(query, [{:gt, id} | rest]) do
|
||||
query
|
||||
|> having([n], max(n.id) > ^id)
|
||||
|> apply_group_cursor_filters(rest)
|
||||
end
|
||||
|
||||
defp apply_group_cursor_filters(query, [{:lt, id} | rest]) do
|
||||
query
|
||||
|> having([n], max(n.id) < ^id)
|
||||
|> apply_group_cursor_filters(rest)
|
||||
end
|
||||
|
||||
defp notification_group_keyed_query(query, grouped_types) do
|
||||
query
|
||||
|> exclude(:preload)
|
||||
|> select([n], %{
|
||||
id: n.id,
|
||||
inserted_at: n.inserted_at,
|
||||
group_key:
|
||||
fragment(
|
||||
"CASE WHEN ? IS NOT NULL AND ?::text = ANY(?) THEN ? ELSE 'ungrouped-' || ?::text END",
|
||||
n.group_key,
|
||||
n.type,
|
||||
type(^grouped_types, {:array, :string}),
|
||||
n.group_key,
|
||||
n.id
|
||||
)
|
||||
})
|
||||
|> subquery()
|
||||
end
|
||||
|
||||
defp representative_notifications(_query, []), do: []
|
||||
|
||||
defp representative_notifications(query, group_rows) do
|
||||
representative_ids = Enum.map(group_rows, & &1.representative_id)
|
||||
|
||||
notifications_by_id =
|
||||
query
|
||||
|> where([n], n.id in ^representative_ids)
|
||||
|> Repo.all()
|
||||
|> Map.new(&{to_string(&1.id), &1})
|
||||
|
||||
group_rows
|
||||
|> Enum.map(&Map.get(notifications_by_id, to_string(&1.representative_id)))
|
||||
|> Enum.filter(& &1)
|
||||
end
|
||||
|
||||
defp notification_group_counts(group_rows) do
|
||||
Map.new(group_rows, &{&1.group_key, &1.notifications_count})
|
||||
end
|
||||
|
||||
defp notification_group_bounds(group_rows) do
|
||||
Map.new(group_rows, fn row ->
|
||||
{row.group_key,
|
||||
%{
|
||||
page_min_id: row.page_min_id,
|
||||
page_max_id: row.page_max_id,
|
||||
latest_page_notification_at: row.latest_page_notification_at
|
||||
}}
|
||||
end)
|
||||
end
|
||||
|
||||
defp notification_group_sample(user, _params, "ungrouped-" <> notification_id) do
|
||||
case Notification.get(user, notification_id) do
|
||||
{:ok, notification} -> [notification]
|
||||
_ -> []
|
||||
end
|
||||
end
|
||||
|
||||
defp notification_group_sample(user, params, group_key) do
|
||||
user
|
||||
|> notification_group_query(group_key, params)
|
||||
|> order_by([n], desc: n.id)
|
||||
|> limit(^@notification_group_sample_limit)
|
||||
|> Repo.all()
|
||||
end
|
||||
|
||||
defp notification_group_metadata(user, "ungrouped-" <> notification_id, _params) do
|
||||
case Notification.get(user, notification_id) do
|
||||
{:ok, notification} ->
|
||||
%{
|
||||
notifications_count: 1,
|
||||
page_min_id: notification.id,
|
||||
page_max_id: notification.id,
|
||||
latest_page_notification_at: notification.inserted_at
|
||||
}
|
||||
|
||||
_ ->
|
||||
nil
|
||||
end
|
||||
end
|
||||
|
||||
defp notification_group_metadata(user, group_key, params) do
|
||||
user
|
||||
|> notification_group_query(group_key, params)
|
||||
|> exclude(:preload)
|
||||
|> select([n], %{
|
||||
notifications_count: count(n.id),
|
||||
page_min_id: min(n.id),
|
||||
page_max_id: max(n.id),
|
||||
latest_page_notification_at: max(n.inserted_at)
|
||||
})
|
||||
|> Repo.one()
|
||||
|> case do
|
||||
%{notifications_count: 0} -> nil
|
||||
metadata -> metadata
|
||||
end
|
||||
end
|
||||
|
||||
defp notification_group_query(user, group_key, params) do
|
||||
user
|
||||
|> notifications_query(params)
|
||||
|> where([n], n.group_key == ^group_key)
|
||||
end
|
||||
|
||||
defp notification_marker_last_read_id(user) do
|
||||
Marker
|
||||
|> where([m], m.user_id == ^user.id and m.timeline == "notifications")
|
||||
|> select([m], m.last_read_id)
|
||||
|> Repo.one()
|
||||
end
|
||||
|
||||
defp restrict_after_marker(query, last_read_id)
|
||||
when is_binary(last_read_id) and last_read_id != "" do
|
||||
where(query, [n], n.id > ^last_read_id)
|
||||
end
|
||||
|
||||
defp restrict_after_marker(query, _last_read_id), do: query
|
||||
|
||||
defp notifications_query(user, params) do
|
||||
options = notification_options(user, params)
|
||||
|
||||
user
|
||||
|> Notification.for_user_query(options)
|
||||
|> restrict(:types, options)
|
||||
|> restrict(:exclude_types, options)
|
||||
|> restrict(:account_ap_id, options)
|
||||
|> Pagination.fetch_paginated(params)
|
||||
end
|
||||
|
||||
defp notification_options(user, params) do
|
||||
options =
|
||||
params
|
||||
|> cast_params()
|
||||
|> Map.update(:include_types, [], fn include_types -> include_types end)
|
||||
|
||||
if ("pleroma:report" not in options.include_types and
|
||||
User.privileged?(user, :reports_manage_reports)) or
|
||||
User.privileged?(user, :reports_manage_reports) do
|
||||
options
|
||||
else
|
||||
options
|
||||
|> Map.update(:exclude_types, ["pleroma:report"], fn current_exclude_types ->
|
||||
current_exclude_types ++ ["pleroma:report"]
|
||||
end)
|
||||
end
|
||||
end
|
||||
|
||||
defp unread_count_limit(params) do
|
||||
params
|
||||
|> Map.get("limit", 100)
|
||||
|> parse_limit(100)
|
||||
|> min(1000)
|
||||
end
|
||||
|
||||
defp parse_limit(limit, _default) when is_integer(limit) and limit > 0, do: limit
|
||||
|
||||
defp parse_limit(limit, default) when is_binary(limit) do
|
||||
case Integer.parse(limit) do
|
||||
{limit, _} when limit > 0 -> limit
|
||||
_ -> default
|
||||
end
|
||||
end
|
||||
|
||||
defp parse_limit(_, default), do: default
|
||||
|
||||
def get_scheduled_activities(user, params \\ %{}) do
|
||||
user
|
||||
|> ScheduledActivity.for_user_query()
|
||||
|
|
@ -95,6 +426,8 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPI do
|
|||
exclude_types: {:array, :string},
|
||||
types: {:array, :string},
|
||||
exclude_visibilities: {:array, :string},
|
||||
grouped_types: {:array, :string},
|
||||
limit: :integer,
|
||||
reblogs: :boolean,
|
||||
with_muted: :boolean,
|
||||
account_ap_id: :string,
|
||||
|
|
|
|||
|
|
@ -17,6 +17,8 @@ defmodule Pleroma.Web.MastodonAPI.InstanceView do
|
|||
reject: "suspend"
|
||||
}
|
||||
|
||||
def mastodon_api_level, do: @mastodon_api_level
|
||||
|
||||
def render("show.json", _) do
|
||||
instance = Config.get(:instance)
|
||||
|
||||
|
|
@ -166,6 +168,7 @@ defmodule Pleroma.Web.MastodonAPI.InstanceView do
|
|||
[
|
||||
"pleroma_api",
|
||||
"mastodon_api",
|
||||
"mastodon_api_grouped_notifications",
|
||||
"mastodon_api_streaming",
|
||||
"polls",
|
||||
"v2_suggestions",
|
||||
|
|
|
|||
|
|
@ -72,6 +72,58 @@ defmodule Pleroma.Web.MastodonAPI.NotificationView do
|
|||
safe_render_many(notifications, NotificationView, "show.json", opts)
|
||||
end
|
||||
|
||||
def render("grouped_index.json", %{notifications: notifications} = opts) do
|
||||
grouped_types = Notification.normalize_grouped_types(opts[:grouped_types])
|
||||
|
||||
opts
|
||||
|> Map.delete(:notifications)
|
||||
|> Map.put(
|
||||
:notification_groups,
|
||||
Notification.group_notifications(notifications, grouped_types)
|
||||
)
|
||||
|> then(&render("grouped_index.json", &1))
|
||||
end
|
||||
|
||||
def render(
|
||||
"grouped_index.json",
|
||||
%{notification_groups: notification_groups, for: reading_user} = opts
|
||||
) do
|
||||
grouped_types = Notification.normalize_grouped_types(opts[:grouped_types])
|
||||
notification_group_counts = Map.get(opts, :notification_group_counts, %{})
|
||||
notification_group_bounds = Map.get(opts, :notification_group_bounds, %{})
|
||||
include_page_metadata = Map.get(opts, :include_page_metadata, true)
|
||||
|
||||
statuses =
|
||||
notification_groups
|
||||
|> Enum.map(&List.first/1)
|
||||
|> Enum.map(&render("show.json", %{notification: &1, for: reading_user}))
|
||||
|> Enum.map(& &1[:status])
|
||||
|> Enum.filter(& &1)
|
||||
|> Enum.uniq_by(& &1[:id])
|
||||
|
||||
actors =
|
||||
notification_groups
|
||||
|> List.flatten()
|
||||
|> notification_actors()
|
||||
|
||||
%{
|
||||
accounts: AccountView.render("index.json", %{users: actors, for: reading_user}),
|
||||
statuses: statuses,
|
||||
notification_groups:
|
||||
Enum.map(
|
||||
notification_groups,
|
||||
&render_group(
|
||||
&1,
|
||||
reading_user,
|
||||
grouped_types,
|
||||
notification_group_counts,
|
||||
notification_group_bounds,
|
||||
include_page_metadata
|
||||
)
|
||||
)
|
||||
}
|
||||
end
|
||||
|
||||
def render(
|
||||
"show.json",
|
||||
%{
|
||||
|
|
@ -95,7 +147,7 @@ defmodule Pleroma.Web.MastodonAPI.NotificationView do
|
|||
|
||||
response = %{
|
||||
id: to_string(notification.id),
|
||||
group_key: "ungrouped-" <> to_string(notification.id),
|
||||
group_key: Notification.group_key(notification),
|
||||
type: notification.type,
|
||||
created_at: CommonAPI.Utils.to_masto_date(notification.inserted_at),
|
||||
account: account,
|
||||
|
|
@ -137,6 +189,104 @@ defmodule Pleroma.Web.MastodonAPI.NotificationView do
|
|||
Map.put(response, :report, report_render)
|
||||
end
|
||||
|
||||
defp render_group(
|
||||
[%Notification{} = notification | _] = notifications,
|
||||
_reading_user,
|
||||
grouped_types,
|
||||
notification_group_counts,
|
||||
notification_group_bounds,
|
||||
include_page_metadata
|
||||
) do
|
||||
latest_notification = List.first(notifications)
|
||||
oldest_notification = List.last(notifications)
|
||||
status_activity = status_activity_for_group(notifications, grouped_types)
|
||||
group_key = Notification.group_key(notification, grouped_types)
|
||||
bounds = Map.get(notification_group_bounds, group_key, %{})
|
||||
|
||||
response = %{
|
||||
group_key: group_key,
|
||||
notifications_count: Map.get(notification_group_counts, group_key, length(notifications)),
|
||||
type: notification.type,
|
||||
most_recent_notification_id:
|
||||
bounds
|
||||
|> Map.get(:page_max_id, latest_notification.id)
|
||||
|> to_string(),
|
||||
sample_account_ids:
|
||||
notifications
|
||||
|> notification_actors()
|
||||
|> Enum.map(&to_string(&1.id))
|
||||
}
|
||||
|
||||
response =
|
||||
if include_page_metadata do
|
||||
Map.merge(response, %{
|
||||
page_min_id:
|
||||
bounds
|
||||
|> Map.get(:page_min_id, oldest_notification.id)
|
||||
|> to_string(),
|
||||
page_max_id:
|
||||
bounds
|
||||
|> Map.get(:page_max_id, latest_notification.id)
|
||||
|> to_string(),
|
||||
latest_page_notification_at:
|
||||
bounds
|
||||
|> Map.get(:latest_page_notification_at, latest_notification.inserted_at)
|
||||
|> CommonAPI.Utils.to_masto_date()
|
||||
})
|
||||
else
|
||||
response
|
||||
end
|
||||
|
||||
if status_activity do
|
||||
Map.put(response, :status_id, to_string(status_activity.id))
|
||||
else
|
||||
response
|
||||
end
|
||||
end
|
||||
|
||||
defp status_activity_for_group([%Notification{} = notification | _], grouped_types) do
|
||||
status_activity_for(notification, grouped_types)
|
||||
end
|
||||
|
||||
defp status_activity_for(%Notification{type: type, activity: activity}, _grouped_types)
|
||||
when type in ["mention", "status", "poll"] do
|
||||
activity
|
||||
end
|
||||
|
||||
defp status_activity_for(%Notification{type: type} = notification, grouped_types)
|
||||
when type in ["favourite", "reblog"] do
|
||||
group_key = Notification.group_key(notification, grouped_types)
|
||||
|
||||
case String.split(group_key, "-", parts: 3) do
|
||||
[^type, activity_id, _bucket] ->
|
||||
case Activity.create_by_id_with_object(activity_id) do
|
||||
%Activity{} = activity -> activity
|
||||
_ -> parent_status_activity(notification.activity)
|
||||
end
|
||||
|
||||
_ ->
|
||||
parent_status_activity(notification.activity)
|
||||
end
|
||||
end
|
||||
|
||||
defp status_activity_for(%Notification{type: type, activity: activity}, _grouped_types)
|
||||
when type in ["update", "pleroma:emoji_reaction"] do
|
||||
parent_status_activity(activity)
|
||||
end
|
||||
|
||||
defp status_activity_for(_, _grouped_types), do: nil
|
||||
|
||||
defp parent_status_activity(activity) do
|
||||
Activity.get_create_by_object_ap_id(object_id_for(activity))
|
||||
end
|
||||
|
||||
defp notification_actors(notifications) do
|
||||
notifications
|
||||
|> Enum.map(&User.get_cached_by_ap_id(&1.activity.data["actor"]))
|
||||
|> Enum.filter(& &1)
|
||||
|> Enum.uniq_by(& &1.id)
|
||||
end
|
||||
|
||||
defp put_emoji(response, activity) do
|
||||
response
|
||||
|> Map.put(:emoji, activity.data["content"])
|
||||
|
|
|
|||
|
|
@ -28,9 +28,13 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
|
|||
# This is a naive way to do this, just spawning a process per activity
|
||||
# to fetch the preview. However it should be fine considering
|
||||
# pagination is restricted to 40 activities at a time
|
||||
defp fetch_rich_media_for_activities(activities) do
|
||||
# Force disable Websockets streaming for backfill jobs,
|
||||
# otherwise old posts can show up on timelines.
|
||||
defp fetch_rich_media_for_activities(activities, opts) do
|
||||
opts = Map.put(opts, :stream, false)
|
||||
|
||||
Enum.each(activities, fn activity ->
|
||||
Card.get_by_activity(activity)
|
||||
Card.get_by_activity(activity, opts)
|
||||
end)
|
||||
end
|
||||
|
||||
|
|
@ -113,7 +117,8 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
|
|||
activities = Enum.filter(opts.activities, & &1)
|
||||
|
||||
# Start prefetching rich media before doing anything else
|
||||
fetch_rich_media_for_activities(activities)
|
||||
fetch_rich_media_for_activities(activities, opts)
|
||||
|
||||
replied_to_activities = get_replied_to_activities(activities)
|
||||
quoted_activities = get_quoted_activities(activities)
|
||||
|
||||
|
|
@ -361,8 +366,10 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
|
|||
|
||||
summary = object.data["summary"] || ""
|
||||
|
||||
# Force disable Websockets streaming for backfill jobs which the below call will create,
|
||||
# otherwise old posts can show up on timelines.
|
||||
card =
|
||||
case Card.get_by_activity(activity) do
|
||||
case Card.get_by_activity(activity, Map.put(opts, :stream, false)) do
|
||||
%Card{} = result -> render("card.json", result)
|
||||
_ -> nil
|
||||
end
|
||||
|
|
|
|||
|
|
@ -67,9 +67,10 @@ defmodule Pleroma.Web.MastodonAPI.WebsocketHandler do
|
|||
|
||||
@impl Phoenix.Socket.Transport
|
||||
def handle_in({text, [opcode: :text]}, state) do
|
||||
with {:ok, %{} = event} <- Jason.decode(text) do
|
||||
handle_client_event(event, state)
|
||||
else
|
||||
case Jason.decode(text) do
|
||||
{:ok, %{} = event} ->
|
||||
handle_client_event(event, state)
|
||||
|
||||
_ ->
|
||||
Logger.error("#{__MODULE__} received non-JSON event: #{inspect(text)}")
|
||||
{:ok, state}
|
||||
|
|
@ -85,11 +86,11 @@ defmodule Pleroma.Web.MastodonAPI.WebsocketHandler do
|
|||
def handle_info({:render_with_user, view, template, item, topic}, state) do
|
||||
user = %User{} = User.get_cached_by_ap_id(state.user.ap_id)
|
||||
|
||||
unless Streamer.filtered_by_user?(user, item) do
|
||||
if Streamer.filtered_by_user?(user, item) do
|
||||
{:ok, state}
|
||||
else
|
||||
message = view.render(template, item, user, topic)
|
||||
{:push, {:text, message}, %{state | user: user}}
|
||||
else
|
||||
{:ok, state}
|
||||
end
|
||||
end
|
||||
|
||||
|
|
@ -253,7 +254,7 @@ defmodule Pleroma.Web.MastodonAPI.WebsocketHandler do
|
|||
|
||||
defp find_sec_websocket_protocol(sec_headers) do
|
||||
Enum.find_value(sec_headers, fn
|
||||
{"sec-websocket-protocol", token} -> token
|
||||
{"sec-websocket-protocol", protocols} -> protocols |> Plug.Conn.Utils.list() |> List.first()
|
||||
_ -> nil
|
||||
end)
|
||||
end
|
||||
|
|
|
|||
104
lib/pleroma/web/mastodon_api/websocket_plug.ex
Normal file
104
lib/pleroma/web/mastodon_api/websocket_plug.ex
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
# Pleroma: A lightweight social networking server
|
||||
# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
|
||||
# SPDX-License-Identifier: AGPL-3.0-only
|
||||
|
||||
defmodule Pleroma.Web.MastodonAPI.WebsocketPlug do
|
||||
@moduledoc """
|
||||
A Phoenix 1.8 compatible WebSocket transport for Mastodon streaming.
|
||||
|
||||
It mirrors Phoenix.Transports.WebSocket, but echoes a successfully authenticated
|
||||
Mastodon-style Sec-WebSocket-Protocol token so browser clients accept the handshake.
|
||||
"""
|
||||
|
||||
@behaviour Plug
|
||||
|
||||
import Plug.Conn
|
||||
|
||||
alias Phoenix.Socket.Transport
|
||||
alias Pleroma.Web.Endpoint
|
||||
alias Pleroma.Web.MastodonAPI.WebsocketHandler
|
||||
|
||||
@connect_info_opts [:check_csrf]
|
||||
|
||||
@impl Plug
|
||||
def init(opts) do
|
||||
path = String.split(Keyword.fetch!(opts, :path), "/", trim: true)
|
||||
websocket = Keyword.fetch!(opts, :websocket)
|
||||
config = Transport.load_config(websocket, Phoenix.Transports.WebSocket)
|
||||
|
||||
{path, config}
|
||||
end
|
||||
|
||||
@impl Plug
|
||||
def call(%{method: "GET", path_info: path} = conn, {path, opts}) do
|
||||
conn
|
||||
|> fetch_query_params()
|
||||
|> Transport.code_reload(Endpoint, opts)
|
||||
|> Transport.transport_log(opts[:transport_log])
|
||||
|> Transport.check_origin(WebsocketHandler, Endpoint, opts)
|
||||
|> connect(opts)
|
||||
end
|
||||
|
||||
def call(%{path_info: path} = conn, {path, _opts}) do
|
||||
conn
|
||||
|> send_resp(400, "")
|
||||
|> halt()
|
||||
end
|
||||
|
||||
def call(conn, _opts), do: conn
|
||||
|
||||
defp connect(%{halted: true} = conn, _opts), do: conn
|
||||
|
||||
defp connect(%{params: params} = conn, opts) do
|
||||
keys = Keyword.get(opts, :connect_info, [])
|
||||
|
||||
connect_info =
|
||||
Transport.connect_info(conn, Endpoint, keys, Keyword.take(opts, @connect_info_opts))
|
||||
|
||||
config = %{
|
||||
endpoint: Endpoint,
|
||||
transport: :websocket,
|
||||
options: opts,
|
||||
params: params,
|
||||
connect_info: connect_info
|
||||
}
|
||||
|
||||
case WebsocketHandler.connect(config) do
|
||||
{:ok, arg} ->
|
||||
try do
|
||||
conn
|
||||
|> echo_sec_websocket_protocol()
|
||||
|> WebSockAdapter.upgrade(WebsocketHandler, arg, opts)
|
||||
|> halt()
|
||||
rescue
|
||||
e in WebSockAdapter.UpgradeError ->
|
||||
conn
|
||||
|> send_resp(400, e.message)
|
||||
|> halt()
|
||||
end
|
||||
|
||||
:error ->
|
||||
conn
|
||||
|> send_resp(403, "")
|
||||
|> halt()
|
||||
|
||||
{:error, reason} ->
|
||||
{m, f, args} = opts[:error_handler]
|
||||
|
||||
halt(apply(m, f, [conn, reason | args]))
|
||||
end
|
||||
end
|
||||
|
||||
defp echo_sec_websocket_protocol(conn) do
|
||||
case get_req_header(conn, "sec-websocket-protocol") do
|
||||
[protocols | _] ->
|
||||
case Plug.Conn.Utils.list(protocols) do
|
||||
[protocol | _] -> put_resp_header(conn, "sec-websocket-protocol", protocol)
|
||||
[] -> conn
|
||||
end
|
||||
|
||||
[] ->
|
||||
conn
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -11,6 +11,8 @@ defmodule Pleroma.Web.RichMedia.Backfill do
|
|||
|
||||
require Logger
|
||||
|
||||
@callback run(map()) :: :ok | Parser.parse_errors() | Helpers.get_errors()
|
||||
|
||||
@cachex Pleroma.Config.get([:cachex, :provider], Cachex)
|
||||
@stream_out_impl Pleroma.Config.get(
|
||||
[__MODULE__, :stream_out],
|
||||
|
|
@ -26,11 +28,7 @@ defmodule Pleroma.Web.RichMedia.Backfill do
|
|||
{:ok, card} = Card.create(url, fields)
|
||||
|
||||
maybe_schedule_expiration(url, fields)
|
||||
|
||||
with %{"activity_id" => activity_id} <- args,
|
||||
false <- is_nil(activity_id) do
|
||||
stream_update(args)
|
||||
end
|
||||
maybe_update_stream(args)
|
||||
|
||||
warm_cache(url_hash, card)
|
||||
:ok
|
||||
|
|
@ -55,12 +53,17 @@ defmodule Pleroma.Web.RichMedia.Backfill do
|
|||
end
|
||||
end
|
||||
|
||||
defp stream_update(%{"activity_id" => activity_id}) do
|
||||
defp maybe_update_stream(%{"activity_id" => activity_id, "stream" => true})
|
||||
when is_binary(activity_id) do
|
||||
Pleroma.Activity.get_by_id(activity_id)
|
||||
|> Pleroma.Activity.normalize()
|
||||
|> @stream_out_impl.stream_out()
|
||||
end
|
||||
|
||||
# Streamer.stream_out returns noop when unsupported activity type is requested to be streamed.
|
||||
# Do the same here for unwanted streaming
|
||||
defp maybe_update_stream(_), do: :noop
|
||||
|
||||
defp warm_cache(key, val), do: @cachex.put(:rich_media_cache, key, val)
|
||||
|
||||
defp negative_cache(key, ttl \\ :timer.minutes(15)),
|
||||
|
|
|
|||
|
|
@ -91,7 +91,18 @@ defmodule Pleroma.Web.RichMedia.Card do
|
|||
nil ->
|
||||
activity_id = Keyword.get(opts, :activity_id, nil)
|
||||
|
||||
RichMediaWorker.new(%{"op" => "backfill", "url" => url, "activity_id" => activity_id})
|
||||
# Nested opts, first layer comes from get_by_activity/2 as Keyword,
|
||||
# second from API views/Federation as Map.
|
||||
# Provide default Map when called directly.
|
||||
opts = Keyword.get(opts, :opts, %{})
|
||||
stream = Map.get(opts, :stream, true)
|
||||
|
||||
RichMediaWorker.new(%{
|
||||
"op" => "backfill",
|
||||
"url" => url,
|
||||
"activity_id" => activity_id,
|
||||
"stream" => stream
|
||||
})
|
||||
|> Oban.insert()
|
||||
|
||||
nil
|
||||
|
|
@ -112,9 +123,11 @@ defmodule Pleroma.Web.RichMedia.Card do
|
|||
end
|
||||
end
|
||||
|
||||
@spec get_by_activity(Activity.t()) :: t() | nil | :error
|
||||
@spec get_by_activity(Activity.t(), %{}) :: t() | nil | :error
|
||||
def get_by_activity(activity, opts \\ %{})
|
||||
|
||||
# Fake/Draft activity
|
||||
def get_by_activity(%Activity{id: "pleroma:fakeid"} = activity) do
|
||||
def get_by_activity(%Activity{id: "pleroma:fakeid"} = activity, _opts) do
|
||||
with {_, true} <- {:config, @config_impl.get([:rich_media, :enabled])},
|
||||
%Object{} = object <- Object.normalize(activity, fetch: false),
|
||||
url when not is_nil(url) <- HTML.extract_first_external_url_from_object(object) do
|
||||
|
|
@ -138,13 +151,13 @@ defmodule Pleroma.Web.RichMedia.Card do
|
|||
end
|
||||
end
|
||||
|
||||
def get_by_activity(activity) do
|
||||
def get_by_activity(activity, opts) do
|
||||
with %Object{} = object <- Object.normalize(activity, fetch: false),
|
||||
{_, nil} <- {:cached, get_cached_url(object, activity.id)} do
|
||||
nil
|
||||
else
|
||||
{:cached, url} ->
|
||||
get_or_backfill_by_url(url, activity_id: activity.id)
|
||||
get_or_backfill_by_url(url, activity_id: activity.id, opts: opts)
|
||||
|
||||
_ ->
|
||||
:error
|
||||
|
|
|
|||
|
|
@ -844,6 +844,16 @@ defmodule Pleroma.Web.Router do
|
|||
get("/directory", DirectoryController, :index)
|
||||
end
|
||||
|
||||
scope "/api/v2", Pleroma.Web.MastodonAPI do
|
||||
pipe_through(:authenticated_api)
|
||||
|
||||
get("/notifications", NotificationController, :grouped_index)
|
||||
get("/notifications/unread_count", NotificationController, :unread_count)
|
||||
get("/notifications/:group_key/accounts", NotificationController, :group_accounts)
|
||||
get("/notifications/:group_key", NotificationController, :show_group)
|
||||
post("/notifications/:group_key/dismiss", NotificationController, :dismiss_group)
|
||||
end
|
||||
|
||||
scope "/api/v2", Pleroma.Web.MastodonAPI do
|
||||
pipe_through(:api)
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue