mirror of
https://akkoma.dev/AkkomaGang/akkoma.git
synced 2024-12-26 02:40:18 +00:00
2c55f7d7cb
Current FedSocket implementation has a bunch of problems. It doesn't have proper error handling (in case of an error the server just doesn't respond until the connection is closed, while the client doesn't match any error messages and just assumes there has been an error after 15s) and the code is full of bad descisions (see: fetch registry which uses uuids for no reason and waits for a response by recursively querying a ets table until the value changes, or double JSON encoding). Sometime ago I almost completed rewriting fedsockets from scrach to adress these issues. However, while doing so, I realized that fedsockets are just too overkill for what they were trying to accomplish, which is reduce the overhead of federation by not signing every message. This could be done without reimplementing failure states and endpoint logic we already have with HTTP by, for example, using TLS cert auth, or switching to a more performant signature algorithm. I opened https://git.pleroma.social/pleroma/pleroma/-/issues/2262 for further discussion on alternatives to fedsockets. From discussions I had with other Pleroma developers it seems like they would approve the descision to remove them as well, therefore I am submitting this patch.
1035 lines
28 KiB
Elixir
1035 lines
28 KiB
Elixir
# Pleroma: A lightweight social networking server
|
|
# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
|
|
# SPDX-License-Identifier: AGPL-3.0-only
|
|
|
|
defmodule Pleroma.Web.ActivityPub.Transmogrifier do
|
|
@moduledoc """
|
|
A module to handle coding from internal to wire ActivityPub and back.
|
|
"""
|
|
alias Pleroma.Activity
|
|
alias Pleroma.EctoType.ActivityPub.ObjectValidators
|
|
alias Pleroma.Maps
|
|
alias Pleroma.Object
|
|
alias Pleroma.Object.Containment
|
|
alias Pleroma.Repo
|
|
alias Pleroma.User
|
|
alias Pleroma.Web.ActivityPub.ActivityPub
|
|
alias Pleroma.Web.ActivityPub.Builder
|
|
alias Pleroma.Web.ActivityPub.ObjectValidator
|
|
alias Pleroma.Web.ActivityPub.Pipeline
|
|
alias Pleroma.Web.ActivityPub.Utils
|
|
alias Pleroma.Web.ActivityPub.Visibility
|
|
alias Pleroma.Web.Federator
|
|
alias Pleroma.Workers.TransmogrifierWorker
|
|
|
|
import Ecto.Query
|
|
|
|
require Logger
|
|
require Pleroma.Constants
|
|
|
|
@doc """
|
|
Modifies an incoming AP object (mastodon format) to our internal format.
|
|
"""
|
|
def fix_object(object, options \\ []) do
|
|
object
|
|
|> strip_internal_fields
|
|
|> fix_actor
|
|
|> fix_url
|
|
|> fix_attachments
|
|
|> fix_context
|
|
|> fix_in_reply_to(options)
|
|
|> fix_emoji
|
|
|> fix_tag
|
|
|> set_sensitive
|
|
|> fix_content_map
|
|
|> fix_addressing
|
|
|> fix_summary
|
|
|> fix_type(options)
|
|
end
|
|
|
|
def fix_summary(%{"summary" => nil} = object) do
|
|
Map.put(object, "summary", "")
|
|
end
|
|
|
|
def fix_summary(%{"summary" => _} = object) do
|
|
# summary is present, nothing to do
|
|
object
|
|
end
|
|
|
|
def fix_summary(object), do: Map.put(object, "summary", "")
|
|
|
|
def fix_addressing_list(map, field) do
|
|
addrs = map[field]
|
|
|
|
cond do
|
|
is_list(addrs) ->
|
|
Map.put(map, field, Enum.filter(addrs, &is_binary/1))
|
|
|
|
is_binary(addrs) ->
|
|
Map.put(map, field, [addrs])
|
|
|
|
true ->
|
|
Map.put(map, field, [])
|
|
end
|
|
end
|
|
|
|
def fix_explicit_addressing(
|
|
%{"to" => to, "cc" => cc} = object,
|
|
explicit_mentions,
|
|
follower_collection
|
|
) do
|
|
explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
|
|
|
|
explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
|
|
|
|
final_cc =
|
|
(cc ++ explicit_cc)
|
|
|> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
|
|
|> Enum.uniq()
|
|
|
|
object
|
|
|> Map.put("to", explicit_to)
|
|
|> Map.put("cc", final_cc)
|
|
end
|
|
|
|
def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
|
|
|
|
# if directMessage flag is set to true, leave the addressing alone
|
|
def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
|
|
|
|
def fix_explicit_addressing(object) do
|
|
explicit_mentions = Utils.determine_explicit_mentions(object)
|
|
|
|
%User{follower_address: follower_collection} =
|
|
object
|
|
|> Containment.get_actor()
|
|
|> User.get_cached_by_ap_id()
|
|
|
|
explicit_mentions =
|
|
explicit_mentions ++
|
|
[
|
|
Pleroma.Constants.as_public(),
|
|
follower_collection
|
|
]
|
|
|
|
fix_explicit_addressing(object, explicit_mentions, follower_collection)
|
|
end
|
|
|
|
# if as:Public is addressed, then make sure the followers collection is also addressed
|
|
# so that the activities will be delivered to local users.
|
|
def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
|
|
recipients = to ++ cc
|
|
|
|
if followers_collection not in recipients do
|
|
cond do
|
|
Pleroma.Constants.as_public() in cc ->
|
|
to = to ++ [followers_collection]
|
|
Map.put(object, "to", to)
|
|
|
|
Pleroma.Constants.as_public() in to ->
|
|
cc = cc ++ [followers_collection]
|
|
Map.put(object, "cc", cc)
|
|
|
|
true ->
|
|
object
|
|
end
|
|
else
|
|
object
|
|
end
|
|
end
|
|
|
|
def fix_implicit_addressing(object, _), do: object
|
|
|
|
def fix_addressing(object) do
|
|
{:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
|
|
followers_collection = User.ap_followers(user)
|
|
|
|
object
|
|
|> fix_addressing_list("to")
|
|
|> fix_addressing_list("cc")
|
|
|> fix_addressing_list("bto")
|
|
|> fix_addressing_list("bcc")
|
|
|> fix_explicit_addressing()
|
|
|> fix_implicit_addressing(followers_collection)
|
|
end
|
|
|
|
def fix_actor(%{"attributedTo" => actor} = object) do
|
|
actor = Containment.get_actor(%{"actor" => actor})
|
|
|
|
# TODO: Remove actor field for Objects
|
|
object
|
|
|> Map.put("actor", actor)
|
|
|> Map.put("attributedTo", actor)
|
|
end
|
|
|
|
def fix_in_reply_to(object, options \\ [])
|
|
|
|
def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
|
|
when not is_nil(in_reply_to) do
|
|
in_reply_to_id = prepare_in_reply_to(in_reply_to)
|
|
depth = (options[:depth] || 0) + 1
|
|
|
|
if Federator.allowed_thread_distance?(depth) do
|
|
with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
|
|
%Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
|
|
object
|
|
|> Map.put("inReplyTo", replied_object.data["id"])
|
|
|> Map.put("context", replied_object.data["context"] || object["conversation"])
|
|
|> Map.drop(["conversation", "inReplyToAtomUri"])
|
|
else
|
|
e ->
|
|
Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
|
|
object
|
|
end
|
|
else
|
|
object
|
|
end
|
|
end
|
|
|
|
def fix_in_reply_to(object, _options), do: object
|
|
|
|
defp prepare_in_reply_to(in_reply_to) do
|
|
cond do
|
|
is_bitstring(in_reply_to) ->
|
|
in_reply_to
|
|
|
|
is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
|
|
in_reply_to["id"]
|
|
|
|
is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
|
|
Enum.at(in_reply_to, 0)
|
|
|
|
true ->
|
|
""
|
|
end
|
|
end
|
|
|
|
def fix_context(object) do
|
|
context = object["context"] || object["conversation"] || Utils.generate_context_id()
|
|
|
|
object
|
|
|> Map.put("context", context)
|
|
|> Map.drop(["conversation"])
|
|
end
|
|
|
|
def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
|
|
attachments =
|
|
Enum.map(attachment, fn data ->
|
|
url =
|
|
cond do
|
|
is_list(data["url"]) -> List.first(data["url"])
|
|
is_map(data["url"]) -> data["url"]
|
|
true -> nil
|
|
end
|
|
|
|
media_type =
|
|
cond do
|
|
is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
|
|
MIME.valid?(data["mediaType"]) -> data["mediaType"]
|
|
MIME.valid?(data["mimeType"]) -> data["mimeType"]
|
|
true -> nil
|
|
end
|
|
|
|
href =
|
|
cond do
|
|
is_map(url) && is_binary(url["href"]) -> url["href"]
|
|
is_binary(data["url"]) -> data["url"]
|
|
is_binary(data["href"]) -> data["href"]
|
|
true -> nil
|
|
end
|
|
|
|
if href do
|
|
attachment_url =
|
|
%{
|
|
"href" => href,
|
|
"type" => Map.get(url || %{}, "type", "Link")
|
|
}
|
|
|> Maps.put_if_present("mediaType", media_type)
|
|
|
|
%{
|
|
"url" => [attachment_url],
|
|
"type" => data["type"] || "Document"
|
|
}
|
|
|> Maps.put_if_present("mediaType", media_type)
|
|
|> Maps.put_if_present("name", data["name"])
|
|
|> Maps.put_if_present("blurhash", data["blurhash"])
|
|
else
|
|
nil
|
|
end
|
|
end)
|
|
|> Enum.filter(& &1)
|
|
|
|
Map.put(object, "attachment", attachments)
|
|
end
|
|
|
|
def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
|
|
object
|
|
|> Map.put("attachment", [attachment])
|
|
|> fix_attachments()
|
|
end
|
|
|
|
def fix_attachments(object), do: object
|
|
|
|
def fix_url(%{"url" => url} = object) when is_map(url) do
|
|
Map.put(object, "url", url["href"])
|
|
end
|
|
|
|
def fix_url(%{"url" => url} = object) when is_list(url) do
|
|
first_element = Enum.at(url, 0)
|
|
|
|
url_string =
|
|
cond do
|
|
is_bitstring(first_element) -> first_element
|
|
is_map(first_element) -> first_element["href"] || ""
|
|
true -> ""
|
|
end
|
|
|
|
Map.put(object, "url", url_string)
|
|
end
|
|
|
|
def fix_url(object), do: object
|
|
|
|
def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
|
|
emoji =
|
|
tags
|
|
|> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
|
|
|> Enum.reduce(%{}, fn data, mapping ->
|
|
name = String.trim(data["name"], ":")
|
|
|
|
Map.put(mapping, name, data["icon"]["url"])
|
|
end)
|
|
|
|
Map.put(object, "emoji", emoji)
|
|
end
|
|
|
|
def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
|
|
name = String.trim(tag["name"], ":")
|
|
emoji = %{name => tag["icon"]["url"]}
|
|
|
|
Map.put(object, "emoji", emoji)
|
|
end
|
|
|
|
def fix_emoji(object), do: object
|
|
|
|
def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
|
|
tags =
|
|
tag
|
|
|> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
|
|
|> Enum.map(fn %{"name" => name} ->
|
|
name
|
|
|> String.slice(1..-1)
|
|
|> String.downcase()
|
|
end)
|
|
|
|
Map.put(object, "tag", tag ++ tags)
|
|
end
|
|
|
|
def fix_tag(%{"tag" => %{} = tag} = object) do
|
|
object
|
|
|> Map.put("tag", [tag])
|
|
|> fix_tag
|
|
end
|
|
|
|
def fix_tag(object), do: object
|
|
|
|
# content map usually only has one language so this will do for now.
|
|
def fix_content_map(%{"contentMap" => content_map} = object) do
|
|
content_groups = Map.to_list(content_map)
|
|
{_, content} = Enum.at(content_groups, 0)
|
|
|
|
Map.put(object, "content", content)
|
|
end
|
|
|
|
def fix_content_map(object), do: object
|
|
|
|
def fix_type(object, options \\ [])
|
|
|
|
def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
|
|
when is_binary(reply_id) do
|
|
with true <- Federator.allowed_thread_distance?(options[:depth]),
|
|
{:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
|
|
Map.put(object, "type", "Answer")
|
|
else
|
|
_ -> object
|
|
end
|
|
end
|
|
|
|
def fix_type(object, _), do: object
|
|
|
|
# Reduce the object list to find the reported user.
|
|
defp get_reported(objects) do
|
|
Enum.reduce_while(objects, nil, fn ap_id, _ ->
|
|
with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
|
|
{:halt, user}
|
|
else
|
|
_ -> {:cont, nil}
|
|
end
|
|
end)
|
|
end
|
|
|
|
# Compatibility wrapper for Mastodon votes
|
|
defp handle_create(%{"object" => %{"type" => "Answer"}} = data, _user) do
|
|
handle_incoming(data)
|
|
end
|
|
|
|
defp handle_create(%{"object" => object} = data, user) do
|
|
%{
|
|
to: data["to"],
|
|
object: object,
|
|
actor: user,
|
|
context: object["context"],
|
|
local: false,
|
|
published: data["published"],
|
|
additional:
|
|
Map.take(data, [
|
|
"cc",
|
|
"directMessage",
|
|
"id"
|
|
])
|
|
}
|
|
|> ActivityPub.create()
|
|
end
|
|
|
|
def handle_incoming(data, options \\ [])
|
|
|
|
# Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
|
|
# with nil ID.
|
|
def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
|
|
with context <- data["context"] || Utils.generate_context_id(),
|
|
content <- data["content"] || "",
|
|
%User{} = actor <- User.get_cached_by_ap_id(actor),
|
|
# Reduce the object list to find the reported user.
|
|
%User{} = account <- get_reported(objects),
|
|
# Remove the reported user from the object list.
|
|
statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
|
|
%{
|
|
actor: actor,
|
|
context: context,
|
|
account: account,
|
|
statuses: statuses,
|
|
content: content,
|
|
additional: %{"cc" => [account.ap_id]}
|
|
}
|
|
|> ActivityPub.flag()
|
|
end
|
|
end
|
|
|
|
# disallow objects with bogus IDs
|
|
def handle_incoming(%{"id" => nil}, _options), do: :error
|
|
def handle_incoming(%{"id" => ""}, _options), do: :error
|
|
# length of https:// = 8, should validate better, but good enough for now.
|
|
def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
|
|
do: :error
|
|
|
|
# TODO: validate those with a Ecto scheme
|
|
# - tags
|
|
# - emoji
|
|
def handle_incoming(
|
|
%{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
|
|
options
|
|
)
|
|
when objtype in ~w{Note Page} do
|
|
actor = Containment.get_actor(data)
|
|
|
|
with nil <- Activity.get_create_by_object_ap_id(object["id"]),
|
|
{:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(actor) do
|
|
data =
|
|
data
|
|
|> Map.put("object", fix_object(object, options))
|
|
|> Map.put("actor", actor)
|
|
|> fix_addressing()
|
|
|
|
with {:ok, created_activity} <- handle_create(data, user) do
|
|
reply_depth = (options[:depth] || 0) + 1
|
|
|
|
if Federator.allowed_thread_distance?(reply_depth) do
|
|
for reply_id <- replies(object) do
|
|
Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
|
|
"id" => reply_id,
|
|
"depth" => reply_depth
|
|
})
|
|
end
|
|
end
|
|
|
|
{:ok, created_activity}
|
|
end
|
|
else
|
|
%Activity{} = activity -> {:ok, activity}
|
|
_e -> :error
|
|
end
|
|
end
|
|
|
|
def handle_incoming(
|
|
%{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
|
|
options
|
|
) do
|
|
actor = Containment.get_actor(data)
|
|
|
|
data =
|
|
Map.put(data, "actor", actor)
|
|
|> fix_addressing
|
|
|
|
with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
|
|
reply_depth = (options[:depth] || 0) + 1
|
|
options = Keyword.put(options, :depth, reply_depth)
|
|
object = fix_object(object, options)
|
|
|
|
params = %{
|
|
to: data["to"],
|
|
object: object,
|
|
actor: user,
|
|
context: nil,
|
|
local: false,
|
|
published: data["published"],
|
|
additional: Map.take(data, ["cc", "id"])
|
|
}
|
|
|
|
ActivityPub.listen(params)
|
|
else
|
|
_e -> :error
|
|
end
|
|
end
|
|
|
|
@misskey_reactions %{
|
|
"like" => "👍",
|
|
"love" => "❤️",
|
|
"laugh" => "😆",
|
|
"hmm" => "🤔",
|
|
"surprise" => "😮",
|
|
"congrats" => "🎉",
|
|
"angry" => "💢",
|
|
"confused" => "😥",
|
|
"rip" => "😇",
|
|
"pudding" => "🍮",
|
|
"star" => "⭐"
|
|
}
|
|
|
|
@doc "Rewrite misskey likes into EmojiReacts"
|
|
def handle_incoming(
|
|
%{
|
|
"type" => "Like",
|
|
"_misskey_reaction" => reaction
|
|
} = data,
|
|
options
|
|
) do
|
|
data
|
|
|> Map.put("type", "EmojiReact")
|
|
|> Map.put("content", @misskey_reactions[reaction] || reaction)
|
|
|> handle_incoming(options)
|
|
end
|
|
|
|
def handle_incoming(
|
|
%{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
|
|
_options
|
|
)
|
|
when objtype in ~w{Question Answer ChatMessage Audio Video Event Article} do
|
|
data = Map.put(data, "object", strip_internal_fields(data["object"]))
|
|
|
|
with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
|
|
nil <- Activity.get_create_by_object_ap_id(obj_id),
|
|
{:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
|
|
{:ok, activity}
|
|
else
|
|
%Activity{} = activity -> {:ok, activity}
|
|
e -> e
|
|
end
|
|
end
|
|
|
|
def handle_incoming(%{"type" => type} = data, _options)
|
|
when type in ~w{Like EmojiReact Announce} do
|
|
with :ok <- ObjectValidator.fetch_actor_and_object(data),
|
|
{:ok, activity, _meta} <-
|
|
Pipeline.common_pipeline(data, local: false) do
|
|
{:ok, activity}
|
|
else
|
|
e -> {:error, e}
|
|
end
|
|
end
|
|
|
|
def handle_incoming(
|
|
%{"type" => type} = data,
|
|
_options
|
|
)
|
|
when type in ~w{Update Block Follow Accept Reject} do
|
|
with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
|
|
{:ok, activity, _} <-
|
|
Pipeline.common_pipeline(data, local: false) do
|
|
{:ok, activity}
|
|
end
|
|
end
|
|
|
|
def handle_incoming(
|
|
%{"type" => "Delete"} = data,
|
|
_options
|
|
) do
|
|
with {:ok, activity, _} <-
|
|
Pipeline.common_pipeline(data, local: false) do
|
|
{:ok, activity}
|
|
else
|
|
{:error, {:validate_object, _}} = e ->
|
|
# Check if we have a create activity for this
|
|
with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
|
|
%Activity{data: %{"actor" => actor}} <-
|
|
Activity.create_by_object_ap_id(object_id) |> Repo.one(),
|
|
# We have one, insert a tombstone and retry
|
|
{:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
|
|
{:ok, _tombstone} <- Object.create(tombstone_data) do
|
|
handle_incoming(data)
|
|
else
|
|
_ -> e
|
|
end
|
|
end
|
|
end
|
|
|
|
def handle_incoming(
|
|
%{
|
|
"type" => "Undo",
|
|
"object" => %{"type" => "Follow", "object" => followed},
|
|
"actor" => follower,
|
|
"id" => id
|
|
} = _data,
|
|
_options
|
|
) do
|
|
with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
|
|
{:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
|
|
{:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
|
|
User.unfollow(follower, followed)
|
|
{:ok, activity}
|
|
else
|
|
_e -> :error
|
|
end
|
|
end
|
|
|
|
def handle_incoming(
|
|
%{
|
|
"type" => "Undo",
|
|
"object" => %{"type" => type}
|
|
} = data,
|
|
_options
|
|
)
|
|
when type in ["Like", "EmojiReact", "Announce", "Block"] do
|
|
with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
|
|
{:ok, activity}
|
|
end
|
|
end
|
|
|
|
# For Undos that don't have the complete object attached, try to find it in our database.
|
|
def handle_incoming(
|
|
%{
|
|
"type" => "Undo",
|
|
"object" => object
|
|
} = activity,
|
|
options
|
|
)
|
|
when is_binary(object) do
|
|
with %Activity{data: data} <- Activity.get_by_ap_id(object) do
|
|
activity
|
|
|> Map.put("object", data)
|
|
|> handle_incoming(options)
|
|
else
|
|
_e -> :error
|
|
end
|
|
end
|
|
|
|
def handle_incoming(
|
|
%{
|
|
"type" => "Move",
|
|
"actor" => origin_actor,
|
|
"object" => origin_actor,
|
|
"target" => target_actor
|
|
},
|
|
_options
|
|
) do
|
|
with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
|
|
{:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
|
|
true <- origin_actor in target_user.also_known_as do
|
|
ActivityPub.move(origin_user, target_user, false)
|
|
else
|
|
_e -> :error
|
|
end
|
|
end
|
|
|
|
def handle_incoming(_, _), do: :error
|
|
|
|
@spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
|
|
def get_obj_helper(id, options \\ []) do
|
|
case Object.normalize(id, true, options) do
|
|
%Object{} = object -> {:ok, object}
|
|
_ -> nil
|
|
end
|
|
end
|
|
|
|
@spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
|
|
def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
|
|
ap_id: ap_id
|
|
})
|
|
when attributed_to == ap_id do
|
|
with {:ok, activity} <-
|
|
handle_incoming(%{
|
|
"type" => "Create",
|
|
"to" => data["to"],
|
|
"cc" => data["cc"],
|
|
"actor" => attributed_to,
|
|
"object" => data
|
|
}) do
|
|
{:ok, Object.normalize(activity)}
|
|
else
|
|
_ -> get_obj_helper(object_id)
|
|
end
|
|
end
|
|
|
|
def get_embedded_obj_helper(object_id, _) do
|
|
get_obj_helper(object_id)
|
|
end
|
|
|
|
def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
|
|
with false <- String.starts_with?(in_reply_to, "http"),
|
|
{:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
|
|
Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
|
|
else
|
|
_e -> object
|
|
end
|
|
end
|
|
|
|
def set_reply_to_uri(obj), do: obj
|
|
|
|
@doc """
|
|
Serialized Mastodon-compatible `replies` collection containing _self-replies_.
|
|
Based on Mastodon's ActivityPub::NoteSerializer#replies.
|
|
"""
|
|
def set_replies(obj_data) do
|
|
replies_uris =
|
|
with limit when limit > 0 <-
|
|
Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
|
|
%Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
|
|
object
|
|
|> Object.self_replies()
|
|
|> select([o], fragment("?->>'id'", o.data))
|
|
|> limit(^limit)
|
|
|> Repo.all()
|
|
else
|
|
_ -> []
|
|
end
|
|
|
|
set_replies(obj_data, replies_uris)
|
|
end
|
|
|
|
defp set_replies(obj, []) do
|
|
obj
|
|
end
|
|
|
|
defp set_replies(obj, replies_uris) do
|
|
replies_collection = %{
|
|
"type" => "Collection",
|
|
"items" => replies_uris
|
|
}
|
|
|
|
Map.merge(obj, %{"replies" => replies_collection})
|
|
end
|
|
|
|
def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
|
|
items
|
|
end
|
|
|
|
def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
|
|
items
|
|
end
|
|
|
|
def replies(_), do: []
|
|
|
|
# Prepares the object of an outgoing create activity.
|
|
def prepare_object(object) do
|
|
object
|
|
|> set_sensitive
|
|
|> add_hashtags
|
|
|> add_mention_tags
|
|
|> add_emoji_tags
|
|
|> add_attributed_to
|
|
|> prepare_attachments
|
|
|> set_conversation
|
|
|> set_reply_to_uri
|
|
|> set_replies
|
|
|> strip_internal_fields
|
|
|> strip_internal_tags
|
|
|> set_type
|
|
end
|
|
|
|
# @doc
|
|
# """
|
|
# internal -> Mastodon
|
|
# """
|
|
|
|
def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
|
|
when activity_type in ["Create", "Listen"] do
|
|
object =
|
|
object_id
|
|
|> Object.normalize()
|
|
|> Map.get(:data)
|
|
|> prepare_object
|
|
|
|
data =
|
|
data
|
|
|> Map.put("object", object)
|
|
|> Map.merge(Utils.make_json_ld_header())
|
|
|> Map.delete("bcc")
|
|
|
|
{:ok, data}
|
|
end
|
|
|
|
def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
|
|
object =
|
|
object_id
|
|
|> Object.normalize()
|
|
|
|
data =
|
|
if Visibility.is_private?(object) && object.data["actor"] == ap_id do
|
|
data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
|
|
else
|
|
data |> maybe_fix_object_url
|
|
end
|
|
|
|
data =
|
|
data
|
|
|> strip_internal_fields
|
|
|> Map.merge(Utils.make_json_ld_header())
|
|
|> Map.delete("bcc")
|
|
|
|
{:ok, data}
|
|
end
|
|
|
|
# Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
|
|
# because of course it does.
|
|
def prepare_outgoing(%{"type" => "Accept"} = data) do
|
|
with follow_activity <- Activity.normalize(data["object"]) do
|
|
object = %{
|
|
"actor" => follow_activity.actor,
|
|
"object" => follow_activity.data["object"],
|
|
"id" => follow_activity.data["id"],
|
|
"type" => "Follow"
|
|
}
|
|
|
|
data =
|
|
data
|
|
|> Map.put("object", object)
|
|
|> Map.merge(Utils.make_json_ld_header())
|
|
|
|
{:ok, data}
|
|
end
|
|
end
|
|
|
|
def prepare_outgoing(%{"type" => "Reject"} = data) do
|
|
with follow_activity <- Activity.normalize(data["object"]) do
|
|
object = %{
|
|
"actor" => follow_activity.actor,
|
|
"object" => follow_activity.data["object"],
|
|
"id" => follow_activity.data["id"],
|
|
"type" => "Follow"
|
|
}
|
|
|
|
data =
|
|
data
|
|
|> Map.put("object", object)
|
|
|> Map.merge(Utils.make_json_ld_header())
|
|
|
|
{:ok, data}
|
|
end
|
|
end
|
|
|
|
def prepare_outgoing(%{"type" => _type} = data) do
|
|
data =
|
|
data
|
|
|> strip_internal_fields
|
|
|> maybe_fix_object_url
|
|
|> Map.merge(Utils.make_json_ld_header())
|
|
|
|
{:ok, data}
|
|
end
|
|
|
|
def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
|
|
with false <- String.starts_with?(object, "http"),
|
|
{:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
|
|
%{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
|
|
relative_object do
|
|
Map.put(data, "object", external_url)
|
|
else
|
|
{:fetch, e} ->
|
|
Logger.error("Couldn't fetch #{object} #{inspect(e)}")
|
|
data
|
|
|
|
_ ->
|
|
data
|
|
end
|
|
end
|
|
|
|
def maybe_fix_object_url(data), do: data
|
|
|
|
def add_hashtags(object) do
|
|
tags =
|
|
(object["tag"] || [])
|
|
|> Enum.map(fn
|
|
# Expand internal representation tags into AS2 tags.
|
|
tag when is_binary(tag) ->
|
|
%{
|
|
"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
|
|
"name" => "##{tag}",
|
|
"type" => "Hashtag"
|
|
}
|
|
|
|
# Do not process tags which are already AS2 tag objects.
|
|
tag when is_map(tag) ->
|
|
tag
|
|
end)
|
|
|
|
Map.put(object, "tag", tags)
|
|
end
|
|
|
|
# TODO These should be added on our side on insertion, it doesn't make much
|
|
# sense to regenerate these all the time
|
|
def add_mention_tags(object) do
|
|
to = object["to"] || []
|
|
cc = object["cc"] || []
|
|
mentioned = User.get_users_from_set(to ++ cc, local_only: false)
|
|
|
|
mentions = Enum.map(mentioned, &build_mention_tag/1)
|
|
|
|
tags = object["tag"] || []
|
|
Map.put(object, "tag", tags ++ mentions)
|
|
end
|
|
|
|
defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
|
|
%{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
|
|
end
|
|
|
|
def take_emoji_tags(%User{emoji: emoji}) do
|
|
emoji
|
|
|> Map.to_list()
|
|
|> Enum.map(&build_emoji_tag/1)
|
|
end
|
|
|
|
# TODO: we should probably send mtime instead of unix epoch time for updated
|
|
def add_emoji_tags(%{"emoji" => emoji} = object) do
|
|
tags = object["tag"] || []
|
|
|
|
out = Enum.map(emoji, &build_emoji_tag/1)
|
|
|
|
Map.put(object, "tag", tags ++ out)
|
|
end
|
|
|
|
def add_emoji_tags(object), do: object
|
|
|
|
defp build_emoji_tag({name, url}) do
|
|
%{
|
|
"icon" => %{"url" => url, "type" => "Image"},
|
|
"name" => ":" <> name <> ":",
|
|
"type" => "Emoji",
|
|
"updated" => "1970-01-01T00:00:00Z",
|
|
"id" => url
|
|
}
|
|
end
|
|
|
|
def set_conversation(object) do
|
|
Map.put(object, "conversation", object["context"])
|
|
end
|
|
|
|
def set_sensitive(%{"sensitive" => _} = object) do
|
|
object
|
|
end
|
|
|
|
def set_sensitive(object) do
|
|
tags = object["tag"] || []
|
|
Map.put(object, "sensitive", "nsfw" in tags)
|
|
end
|
|
|
|
def set_type(%{"type" => "Answer"} = object) do
|
|
Map.put(object, "type", "Note")
|
|
end
|
|
|
|
def set_type(object), do: object
|
|
|
|
def add_attributed_to(object) do
|
|
attributed_to = object["attributedTo"] || object["actor"]
|
|
Map.put(object, "attributedTo", attributed_to)
|
|
end
|
|
|
|
# TODO: Revisit this
|
|
def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object
|
|
|
|
def prepare_attachments(object) do
|
|
attachments =
|
|
object
|
|
|> Map.get("attachment", [])
|
|
|> Enum.map(fn data ->
|
|
[%{"mediaType" => media_type, "href" => href} | _] = data["url"]
|
|
|
|
%{
|
|
"url" => href,
|
|
"mediaType" => media_type,
|
|
"name" => data["name"],
|
|
"type" => "Document"
|
|
}
|
|
end)
|
|
|
|
Map.put(object, "attachment", attachments)
|
|
end
|
|
|
|
def strip_internal_fields(object) do
|
|
Map.drop(object, Pleroma.Constants.object_internal_fields())
|
|
end
|
|
|
|
defp strip_internal_tags(%{"tag" => tags} = object) do
|
|
tags = Enum.filter(tags, fn x -> is_map(x) end)
|
|
|
|
Map.put(object, "tag", tags)
|
|
end
|
|
|
|
defp strip_internal_tags(object), do: object
|
|
|
|
def perform(:user_upgrade, user) do
|
|
# we pass a fake user so that the followers collection is stripped away
|
|
old_follower_address = User.ap_followers(%User{nickname: user.nickname})
|
|
|
|
from(
|
|
a in Activity,
|
|
where: ^old_follower_address in a.recipients,
|
|
update: [
|
|
set: [
|
|
recipients:
|
|
fragment(
|
|
"array_replace(?,?,?)",
|
|
a.recipients,
|
|
^old_follower_address,
|
|
^user.follower_address
|
|
)
|
|
]
|
|
]
|
|
)
|
|
|> Repo.update_all([])
|
|
end
|
|
|
|
def upgrade_user_from_ap_id(ap_id) do
|
|
with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
|
|
{:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
|
|
{:ok, user} <- update_user(user, data) do
|
|
TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
|
|
{:ok, user}
|
|
else
|
|
%User{} = user -> {:ok, user}
|
|
e -> e
|
|
end
|
|
end
|
|
|
|
defp update_user(user, data) do
|
|
user
|
|
|> User.remote_user_changeset(data)
|
|
|> User.update_and_set_cache()
|
|
end
|
|
|
|
def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
|
|
Map.put(data, "url", url["href"])
|
|
end
|
|
|
|
def maybe_fix_user_url(data), do: data
|
|
|
|
def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
|
|
end
|