git.squeep.com Git - akkoma/blob - lib/pleroma/web/activity_pub/transmogrifier.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.Transmogrifier do
   6   @moduledoc """
   7   A module to handle coding from internal to wire ActivityPub and back.
   8   """
   9   alias Pleroma.Activity
  10   alias Pleroma.EctoType.ActivityPub.ObjectValidators
  11   alias Pleroma.Maps
  12   alias Pleroma.Object
  13   alias Pleroma.Object.Containment
  14   alias Pleroma.Repo
  15   alias Pleroma.User
  16   alias Pleroma.Web.ActivityPub.ActivityPub
  17   alias Pleroma.Web.ActivityPub.Builder
  18   alias Pleroma.Web.ActivityPub.ObjectValidator
  19   alias Pleroma.Web.ActivityPub.Pipeline
  20   alias Pleroma.Web.ActivityPub.Utils
  21   alias Pleroma.Web.ActivityPub.Visibility
  22   alias Pleroma.Web.Federator
  23   alias Pleroma.Workers.TransmogrifierWorker
  24
  25   import Ecto.Query
  26
  27   require Logger
  28   require Pleroma.Constants
  29
  30   @doc """
  31   Modifies an incoming AP object (mastodon format) to our internal format.
  32   """
  33   def fix_object(object, options \\ []) do
  34     object
  35     |> strip_internal_fields
  36     |> fix_actor
  37     |> fix_url
  38     |> fix_attachments
  39     |> fix_context
  40     |> fix_in_reply_to(options)
  41     |> fix_emoji
  42     |> fix_tag
  43     |> set_sensitive
  44     |> fix_content_map
  45     |> fix_addressing
  46     |> fix_summary
  47     |> fix_type(options)
  48   end
  49
  50   def fix_summary(%{"summary" => nil} = object) do
  51     Map.put(object, "summary", "")
  52   end
  53
  54   def fix_summary(%{"summary" => _} = object) do
  55     # summary is present, nothing to do
  56     object
  57   end
  58
  59   def fix_summary(object), do: Map.put(object, "summary", "")
  60
  61   def fix_addressing_list(map, field) do
  62     addrs = map[field]
  63
  64     cond do
  65       is_list(addrs) ->
  66         Map.put(map, field, Enum.filter(addrs, &is_binary/1))
  67
  68       is_binary(addrs) ->
  69         Map.put(map, field, [addrs])
  70
  71       true ->
  72         Map.put(map, field, [])
  73     end
  74   end
  75
  76   def fix_explicit_addressing(
  77         %{"to" => to, "cc" => cc} = object,
  78         explicit_mentions,
  79         follower_collection
  80       ) do
  81     explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
  82
  83     explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
  84
  85     final_cc =
  86       (cc ++ explicit_cc)
  87       |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
  88       |> Enum.uniq()
  89
  90     object
  91     |> Map.put("to", explicit_to)
  92     |> Map.put("cc", final_cc)
  93   end
  94
  95   def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
  96
  97   # if directMessage flag is set to true, leave the addressing alone
  98   def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
  99
 100   def fix_explicit_addressing(object) do
 101     explicit_mentions = Utils.determine_explicit_mentions(object)
 102
 103     %User{follower_address: follower_collection} =
 104       object
 105       |> Containment.get_actor()
 106       |> User.get_cached_by_ap_id()
 107
 108     explicit_mentions =
 109       explicit_mentions ++
 110         [
 111           Pleroma.Constants.as_public(),
 112           follower_collection
 113         ]
 114
 115     fix_explicit_addressing(object, explicit_mentions, follower_collection)
 116   end
 117
 118   # if as:Public is addressed, then make sure the followers collection is also addressed
 119   # so that the activities will be delivered to local users.
 120   def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
 121     recipients = to ++ cc
 122
 123     if followers_collection not in recipients do
 124       cond do
 125         Pleroma.Constants.as_public() in cc ->
 126           to = to ++ [followers_collection]
 127           Map.put(object, "to", to)
 128
 129         Pleroma.Constants.as_public() in to ->
 130           cc = cc ++ [followers_collection]
 131           Map.put(object, "cc", cc)
 132
 133         true ->
 134           object
 135       end
 136     else
 137       object
 138     end
 139   end
 140
 141   def fix_implicit_addressing(object, _), do: object
 142
 143   def fix_addressing(object) do
 144     {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
 145     followers_collection = User.ap_followers(user)
 146
 147     object
 148     |> fix_addressing_list("to")
 149     |> fix_addressing_list("cc")
 150     |> fix_addressing_list("bto")
 151     |> fix_addressing_list("bcc")
 152     |> fix_explicit_addressing()
 153     |> fix_implicit_addressing(followers_collection)
 154   end
 155
 156   def fix_actor(%{"attributedTo" => actor} = object) do
 157     actor = Containment.get_actor(%{"actor" => actor})
 158
 159     # TODO: Remove actor field for Objects
 160     object
 161     |> Map.put("actor", actor)
 162     |> Map.put("attributedTo", actor)
 163   end
 164
 165   def fix_in_reply_to(object, options \\ [])
 166
 167   def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
 168       when not is_nil(in_reply_to) do
 169     in_reply_to_id = prepare_in_reply_to(in_reply_to)
 170     depth = (options[:depth] || 0) + 1
 171
 172     if Federator.allowed_thread_distance?(depth) do
 173       with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
 174            %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
 175         object
 176         |> Map.put("inReplyTo", replied_object.data["id"])
 177         |> Map.put("context", replied_object.data["context"] || object["conversation"])
 178         |> Map.drop(["conversation", "inReplyToAtomUri"])
 179       else
 180         e ->
 181           Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
 182           object
 183       end
 184     else
 185       object
 186     end
 187   end
 188
 189   def fix_in_reply_to(object, _options), do: object
 190
 191   defp prepare_in_reply_to(in_reply_to) do
 192     cond do
 193       is_bitstring(in_reply_to) ->
 194         in_reply_to
 195
 196       is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
 197         in_reply_to["id"]
 198
 199       is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
 200         Enum.at(in_reply_to, 0)
 201
 202       true ->
 203         ""
 204     end
 205   end
 206
 207   def fix_context(object) do
 208     context = object["context"] || object["conversation"] || Utils.generate_context_id()
 209
 210     object
 211     |> Map.put("context", context)
 212     |> Map.drop(["conversation"])
 213   end
 214
 215   def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
 216     attachments =
 217       Enum.map(attachment, fn data ->
 218         url =
 219           cond do
 220             is_list(data["url"]) -> List.first(data["url"])
 221             is_map(data["url"]) -> data["url"]
 222             true -> nil
 223           end
 224
 225         media_type =
 226           cond do
 227             is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
 228             MIME.valid?(data["mediaType"]) -> data["mediaType"]
 229             MIME.valid?(data["mimeType"]) -> data["mimeType"]
 230             true -> nil
 231           end
 232
 233         href =
 234           cond do
 235             is_map(url) && is_binary(url["href"]) -> url["href"]
 236             is_binary(data["url"]) -> data["url"]
 237             is_binary(data["href"]) -> data["href"]
 238             true -> nil
 239           end
 240
 241         if href do
 242           attachment_url =
 243             %{
 244               "href" => href,
 245               "type" => Map.get(url || %{}, "type", "Link")
 246             }
 247             |> Maps.put_if_present("mediaType", media_type)
 248
 249           %{
 250             "url" => [attachment_url],
 251             "type" => data["type"] || "Document"
 252           }
 253           |> Maps.put_if_present("mediaType", media_type)
 254           |> Maps.put_if_present("name", data["name"])
 255           |> Maps.put_if_present("blurhash", data["blurhash"])
 256         else
 257           nil
 258         end
 259       end)
 260       |> Enum.filter(& &1)
 261
 262     Map.put(object, "attachment", attachments)
 263   end
 264
 265   def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
 266     object
 267     |> Map.put("attachment", [attachment])
 268     |> fix_attachments()
 269   end
 270
 271   def fix_attachments(object), do: object
 272
 273   def fix_url(%{"url" => url} = object) when is_map(url) do
 274     Map.put(object, "url", url["href"])
 275   end
 276
 277   def fix_url(%{"url" => url} = object) when is_list(url) do
 278     first_element = Enum.at(url, 0)
 279
 280     url_string =
 281       cond do
 282         is_bitstring(first_element) -> first_element
 283         is_map(first_element) -> first_element["href"] || ""
 284         true -> ""
 285       end
 286
 287     Map.put(object, "url", url_string)
 288   end
 289
 290   def fix_url(object), do: object
 291
 292   def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
 293     emoji =
 294       tags
 295       |> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
 296       |> Enum.reduce(%{}, fn data, mapping ->
 297         name = String.trim(data["name"], ":")
 298
 299         Map.put(mapping, name, data["icon"]["url"])
 300       end)
 301
 302     Map.put(object, "emoji", emoji)
 303   end
 304
 305   def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
 306     name = String.trim(tag["name"], ":")
 307     emoji = %{name => tag["icon"]["url"]}
 308
 309     Map.put(object, "emoji", emoji)
 310   end
 311
 312   def fix_emoji(object), do: object
 313
 314   def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
 315     tags =
 316       tag
 317       |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
 318       |> Enum.map(fn %{"name" => name} ->
 319         name
 320         |> String.slice(1..-1)
 321         |> String.downcase()
 322       end)
 323
 324     Map.put(object, "tag", tag ++ tags)
 325   end
 326
 327   def fix_tag(%{"tag" => %{} = tag} = object) do
 328     object
 329     |> Map.put("tag", [tag])
 330     |> fix_tag
 331   end
 332
 333   def fix_tag(object), do: object
 334
 335   # content map usually only has one language so this will do for now.
 336   def fix_content_map(%{"contentMap" => content_map} = object) do
 337     content_groups = Map.to_list(content_map)
 338     {_, content} = Enum.at(content_groups, 0)
 339
 340     Map.put(object, "content", content)
 341   end
 342
 343   def fix_content_map(object), do: object
 344
 345   def fix_type(object, options \\ [])
 346
 347   def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
 348       when is_binary(reply_id) do
 349     with true <- Federator.allowed_thread_distance?(options[:depth]),
 350          {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
 351       Map.put(object, "type", "Answer")
 352     else
 353       _ -> object
 354     end
 355   end
 356
 357   def fix_type(object, _), do: object
 358
 359   # Reduce the object list to find the reported user.
 360   defp get_reported(objects) do
 361     Enum.reduce_while(objects, nil, fn ap_id, _ ->
 362       with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
 363         {:halt, user}
 364       else
 365         _ -> {:cont, nil}
 366       end
 367     end)
 368   end
 369
 370   # Compatibility wrapper for Mastodon votes
 371   defp handle_create(%{"object" => %{"type" => "Answer"}} = data, _user) do
 372     handle_incoming(data)
 373   end
 374
 375   defp handle_create(%{"object" => object} = data, user) do
 376     %{
 377       to: data["to"],
 378       object: object,
 379       actor: user,
 380       context: object["context"],
 381       local: false,
 382       published: data["published"],
 383       additional:
 384         Map.take(data, [
 385           "cc",
 386           "directMessage",
 387           "id"
 388         ])
 389     }
 390     |> ActivityPub.create()
 391   end
 392
 393   def handle_incoming(data, options \\ [])
 394
 395   # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
 396   # with nil ID.
 397   def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
 398     with context <- data["context"] || Utils.generate_context_id(),
 399          content <- data["content"] || "",
 400          %User{} = actor <- User.get_cached_by_ap_id(actor),
 401          # Reduce the object list to find the reported user.
 402          %User{} = account <- get_reported(objects),
 403          # Remove the reported user from the object list.
 404          statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
 405       %{
 406         actor: actor,
 407         context: context,
 408         account: account,
 409         statuses: statuses,
 410         content: content,
 411         additional: %{"cc" => [account.ap_id]}
 412       }
 413       |> ActivityPub.flag()
 414     end
 415   end
 416
 417   # disallow objects with bogus IDs
 418   def handle_incoming(%{"id" => nil}, _options), do: :error
 419   def handle_incoming(%{"id" => ""}, _options), do: :error
 420   # length of https:// = 8, should validate better, but good enough for now.
 421   def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
 422     do: :error
 423
 424   # TODO: validate those with a Ecto scheme
 425   # - tags
 426   # - emoji
 427   def handle_incoming(
 428         %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
 429         options
 430       )
 431       when objtype in ~w{Note Page} do
 432     actor = Containment.get_actor(data)
 433
 434     with nil <- Activity.get_create_by_object_ap_id(object["id"]),
 435          {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(actor) do
 436       data =
 437         data
 438         |> Map.put("object", fix_object(object, options))
 439         |> Map.put("actor", actor)
 440         |> fix_addressing()
 441
 442       with {:ok, created_activity} <- handle_create(data, user) do
 443         reply_depth = (options[:depth] || 0) + 1
 444
 445         if Federator.allowed_thread_distance?(reply_depth) do
 446           for reply_id <- replies(object) do
 447             Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
 448               "id" => reply_id,
 449               "depth" => reply_depth
 450             })
 451           end
 452         end
 453
 454         {:ok, created_activity}
 455       end
 456     else
 457       %Activity{} = activity -> {:ok, activity}
 458       _e -> :error
 459     end
 460   end
 461
 462   def handle_incoming(
 463         %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
 464         options
 465       ) do
 466     actor = Containment.get_actor(data)
 467
 468     data =
 469       Map.put(data, "actor", actor)
 470       |> fix_addressing
 471
 472     with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
 473       reply_depth = (options[:depth] || 0) + 1
 474       options = Keyword.put(options, :depth, reply_depth)
 475       object = fix_object(object, options)
 476
 477       params = %{
 478         to: data["to"],
 479         object: object,
 480         actor: user,
 481         context: nil,
 482         local: false,
 483         published: data["published"],
 484         additional: Map.take(data, ["cc", "id"])
 485       }
 486
 487       ActivityPub.listen(params)
 488     else
 489       _e -> :error
 490     end
 491   end
 492
 493   @misskey_reactions %{
 494     "like" => "👍",
 495     "love" => "❤️",
 496     "laugh" => "😆",
 497     "hmm" => "🤔",
 498     "surprise" => "😮",
 499     "congrats" => "🎉",
 500     "angry" => "💢",
 501     "confused" => "😥",
 502     "rip" => "😇",
 503     "pudding" => "🍮",
 504     "star" => "⭐"
 505   }
 506
 507   @doc "Rewrite misskey likes into EmojiReacts"
 508   def handle_incoming(
 509         %{
 510           "type" => "Like",
 511           "_misskey_reaction" => reaction
 512         } = data,
 513         options
 514       ) do
 515     data
 516     |> Map.put("type", "EmojiReact")
 517     |> Map.put("content", @misskey_reactions[reaction] || reaction)
 518     |> handle_incoming(options)
 519   end
 520
 521   def handle_incoming(
 522         %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
 523         _options
 524       )
 525       when objtype in ~w{Question Answer ChatMessage Audio Video Event Article} do
 526     data = Map.put(data, "object", strip_internal_fields(data["object"]))
 527
 528     with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
 529          nil <- Activity.get_create_by_object_ap_id(obj_id),
 530          {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
 531       {:ok, activity}
 532     else
 533       %Activity{} = activity -> {:ok, activity}
 534       e -> e
 535     end
 536   end
 537
 538   def handle_incoming(%{"type" => type} = data, _options)
 539       when type in ~w{Like EmojiReact Announce} do
 540     with :ok <- ObjectValidator.fetch_actor_and_object(data),
 541          {:ok, activity, _meta} <-
 542            Pipeline.common_pipeline(data, local: false) do
 543       {:ok, activity}
 544     else
 545       e -> {:error, e}
 546     end
 547   end
 548
 549   def handle_incoming(
 550         %{"type" => type} = data,
 551         _options
 552       )
 553       when type in ~w{Update Block Follow Accept Reject} do
 554     with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
 555          {:ok, activity, _} <-
 556            Pipeline.common_pipeline(data, local: false) do
 557       {:ok, activity}
 558     end
 559   end
 560
 561   def handle_incoming(
 562         %{"type" => "Delete"} = data,
 563         _options
 564       ) do
 565     with {:ok, activity, _} <-
 566            Pipeline.common_pipeline(data, local: false) do
 567       {:ok, activity}
 568     else
 569       {:error, {:validate_object, _}} = e ->
 570         # Check if we have a create activity for this
 571         with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
 572              %Activity{data: %{"actor" => actor}} <-
 573                Activity.create_by_object_ap_id(object_id) |> Repo.one(),
 574              # We have one, insert a tombstone and retry
 575              {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
 576              {:ok, _tombstone} <- Object.create(tombstone_data) do
 577           handle_incoming(data)
 578         else
 579           _ -> e
 580         end
 581     end
 582   end
 583
 584   def handle_incoming(
 585         %{
 586           "type" => "Undo",
 587           "object" => %{"type" => "Follow", "object" => followed},
 588           "actor" => follower,
 589           "id" => id
 590         } = _data,
 591         _options
 592       ) do
 593     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 594          {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
 595          {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
 596       User.unfollow(follower, followed)
 597       {:ok, activity}
 598     else
 599       _e -> :error
 600     end
 601   end
 602
 603   def handle_incoming(
 604         %{
 605           "type" => "Undo",
 606           "object" => %{"type" => type}
 607         } = data,
 608         _options
 609       )
 610       when type in ["Like", "EmojiReact", "Announce", "Block"] do
 611     with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
 612       {:ok, activity}
 613     end
 614   end
 615
 616   # For Undos that don't have the complete object attached, try to find it in our database.
 617   def handle_incoming(
 618         %{
 619           "type" => "Undo",
 620           "object" => object
 621         } = activity,
 622         options
 623       )
 624       when is_binary(object) do
 625     with %Activity{data: data} <- Activity.get_by_ap_id(object) do
 626       activity
 627       |> Map.put("object", data)
 628       |> handle_incoming(options)
 629     else
 630       _e -> :error
 631     end
 632   end
 633
 634   def handle_incoming(
 635         %{
 636           "type" => "Move",
 637           "actor" => origin_actor,
 638           "object" => origin_actor,
 639           "target" => target_actor
 640         },
 641         _options
 642       ) do
 643     with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
 644          {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
 645          true <- origin_actor in target_user.also_known_as do
 646       ActivityPub.move(origin_user, target_user, false)
 647     else
 648       _e -> :error
 649     end
 650   end
 651
 652   def handle_incoming(_, _), do: :error
 653
 654   @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
 655   def get_obj_helper(id, options \\ []) do
 656     options = Keyword.put(options, :fetch, true)
 657
 658     case Object.normalize(id, options) do
 659       %Object{} = object -> {:ok, object}
 660       _ -> nil
 661     end
 662   end
 663
 664   @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
 665   def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
 666         ap_id: ap_id
 667       })
 668       when attributed_to == ap_id do
 669     with {:ok, activity} <-
 670            handle_incoming(%{
 671              "type" => "Create",
 672              "to" => data["to"],
 673              "cc" => data["cc"],
 674              "actor" => attributed_to,
 675              "object" => data
 676            }) do
 677       {:ok, Object.normalize(activity, fetch: false)}
 678     else
 679       _ -> get_obj_helper(object_id)
 680     end
 681   end
 682
 683   def get_embedded_obj_helper(object_id, _) do
 684     get_obj_helper(object_id)
 685   end
 686
 687   def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
 688     with false <- String.starts_with?(in_reply_to, "http"),
 689          {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
 690       Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
 691     else
 692       _e -> object
 693     end
 694   end
 695
 696   def set_reply_to_uri(obj), do: obj
 697
 698   @doc """
 699   Serialized Mastodon-compatible `replies` collection containing _self-replies_.
 700   Based on Mastodon's ActivityPub::NoteSerializer#replies.
 701   """
 702   def set_replies(obj_data) do
 703     replies_uris =
 704       with limit when limit > 0 <-
 705              Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
 706            %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
 707         object
 708         |> Object.self_replies()
 709         |> select([o], fragment("?->>'id'", o.data))
 710         |> limit(^limit)
 711         |> Repo.all()
 712       else
 713         _ -> []
 714       end
 715
 716     set_replies(obj_data, replies_uris)
 717   end
 718
 719   defp set_replies(obj, []) do
 720     obj
 721   end
 722
 723   defp set_replies(obj, replies_uris) do
 724     replies_collection = %{
 725       "type" => "Collection",
 726       "items" => replies_uris
 727     }
 728
 729     Map.merge(obj, %{"replies" => replies_collection})
 730   end
 731
 732   def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
 733     items
 734   end
 735
 736   def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
 737     items
 738   end
 739
 740   def replies(_), do: []
 741
 742   # Prepares the object of an outgoing create activity.
 743   def prepare_object(object) do
 744     object
 745     |> set_sensitive
 746     |> add_hashtags
 747     |> add_mention_tags
 748     |> add_emoji_tags
 749     |> add_attributed_to
 750     |> prepare_attachments
 751     |> set_conversation
 752     |> set_reply_to_uri
 753     |> set_replies
 754     |> strip_internal_fields
 755     |> strip_internal_tags
 756     |> set_type
 757   end
 758
 759   #  @doc
 760   #  """
 761   #  internal -> Mastodon
 762   #  """
 763
 764   def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
 765       when activity_type in ["Create", "Listen"] do
 766     object =
 767       object_id
 768       |> Object.normalize(fetch: false)
 769       |> Map.get(:data)
 770       |> prepare_object
 771
 772     data =
 773       data
 774       |> Map.put("object", object)
 775       |> Map.merge(Utils.make_json_ld_header())
 776       |> Map.delete("bcc")
 777
 778     {:ok, data}
 779   end
 780
 781   def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
 782     object =
 783       object_id
 784       |> Object.normalize(fetch: false)
 785
 786     data =
 787       if Visibility.is_private?(object) && object.data["actor"] == ap_id do
 788         data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
 789       else
 790         data |> maybe_fix_object_url
 791       end
 792
 793     data =
 794       data
 795       |> strip_internal_fields
 796       |> Map.merge(Utils.make_json_ld_header())
 797       |> Map.delete("bcc")
 798
 799     {:ok, data}
 800   end
 801
 802   # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
 803   # because of course it does.
 804   def prepare_outgoing(%{"type" => "Accept"} = data) do
 805     with follow_activity <- Activity.normalize(data["object"]) do
 806       object = %{
 807         "actor" => follow_activity.actor,
 808         "object" => follow_activity.data["object"],
 809         "id" => follow_activity.data["id"],
 810         "type" => "Follow"
 811       }
 812
 813       data =
 814         data
 815         |> Map.put("object", object)
 816         |> Map.merge(Utils.make_json_ld_header())
 817
 818       {:ok, data}
 819     end
 820   end
 821
 822   def prepare_outgoing(%{"type" => "Reject"} = data) do
 823     with follow_activity <- Activity.normalize(data["object"]) do
 824       object = %{
 825         "actor" => follow_activity.actor,
 826         "object" => follow_activity.data["object"],
 827         "id" => follow_activity.data["id"],
 828         "type" => "Follow"
 829       }
 830
 831       data =
 832         data
 833         |> Map.put("object", object)
 834         |> Map.merge(Utils.make_json_ld_header())
 835
 836       {:ok, data}
 837     end
 838   end
 839
 840   def prepare_outgoing(%{"type" => _type} = data) do
 841     data =
 842       data
 843       |> strip_internal_fields
 844       |> maybe_fix_object_url
 845       |> Map.merge(Utils.make_json_ld_header())
 846
 847     {:ok, data}
 848   end
 849
 850   def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
 851     with false <- String.starts_with?(object, "http"),
 852          {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
 853          %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
 854            relative_object do
 855       Map.put(data, "object", external_url)
 856     else
 857       {:fetch, e} ->
 858         Logger.error("Couldn't fetch #{object} #{inspect(e)}")
 859         data
 860
 861       _ ->
 862         data
 863     end
 864   end
 865
 866   def maybe_fix_object_url(data), do: data
 867
 868   def add_hashtags(object) do
 869     tags =
 870       (object["tag"] || [])
 871       |> Enum.map(fn
 872         # Expand internal representation tags into AS2 tags.
 873         tag when is_binary(tag) ->
 874           %{
 875             "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
 876             "name" => "##{tag}",
 877             "type" => "Hashtag"
 878           }
 879
 880         # Do not process tags which are already AS2 tag objects.
 881         tag when is_map(tag) ->
 882           tag
 883       end)
 884
 885     Map.put(object, "tag", tags)
 886   end
 887
 888   # TODO These should be added on our side on insertion, it doesn't make much
 889   # sense to regenerate these all the time
 890   def add_mention_tags(object) do
 891     to = object["to"] || []
 892     cc = object["cc"] || []
 893     mentioned = User.get_users_from_set(to ++ cc, local_only: false)
 894
 895     mentions = Enum.map(mentioned, &build_mention_tag/1)
 896
 897     tags = object["tag"] || []
 898     Map.put(object, "tag", tags ++ mentions)
 899   end
 900
 901   defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
 902     %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
 903   end
 904
 905   def take_emoji_tags(%User{emoji: emoji}) do
 906     emoji
 907     |> Map.to_list()
 908     |> Enum.map(&build_emoji_tag/1)
 909   end
 910
 911   # TODO: we should probably send mtime instead of unix epoch time for updated
 912   def add_emoji_tags(%{"emoji" => emoji} = object) do
 913     tags = object["tag"] || []
 914
 915     out = Enum.map(emoji, &build_emoji_tag/1)
 916
 917     Map.put(object, "tag", tags ++ out)
 918   end
 919
 920   def add_emoji_tags(object), do: object
 921
 922   defp build_emoji_tag({name, url}) do
 923     %{
 924       "icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
 925       "name" => ":" <> name <> ":",
 926       "type" => "Emoji",
 927       "updated" => "1970-01-01T00:00:00Z",
 928       "id" => url
 929     }
 930   end
 931
 932   def set_conversation(object) do
 933     Map.put(object, "conversation", object["context"])
 934   end
 935
 936   def set_sensitive(%{"sensitive" => _} = object) do
 937     object
 938   end
 939
 940   def set_sensitive(object) do
 941     tags = object["tag"] || []
 942     Map.put(object, "sensitive", "nsfw" in tags)
 943   end
 944
 945   def set_type(%{"type" => "Answer"} = object) do
 946     Map.put(object, "type", "Note")
 947   end
 948
 949   def set_type(object), do: object
 950
 951   def add_attributed_to(object) do
 952     attributed_to = object["attributedTo"] || object["actor"]
 953     Map.put(object, "attributedTo", attributed_to)
 954   end
 955
 956   # TODO: Revisit this
 957   def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object
 958
 959   def prepare_attachments(object) do
 960     attachments =
 961       object
 962       |> Map.get("attachment", [])
 963       |> Enum.map(fn data ->
 964         [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
 965
 966         %{
 967           "url" => href,
 968           "mediaType" => media_type,
 969           "name" => data["name"],
 970           "type" => "Document"
 971         }
 972       end)
 973
 974     Map.put(object, "attachment", attachments)
 975   end
 976
 977   def strip_internal_fields(object) do
 978     Map.drop(object, Pleroma.Constants.object_internal_fields())
 979   end
 980
 981   defp strip_internal_tags(%{"tag" => tags} = object) do
 982     tags = Enum.filter(tags, fn x -> is_map(x) end)
 983
 984     Map.put(object, "tag", tags)
 985   end
 986
 987   defp strip_internal_tags(object), do: object
 988
 989   def perform(:user_upgrade, user) do
 990     # we pass a fake user so that the followers collection is stripped away
 991     old_follower_address = User.ap_followers(%User{nickname: user.nickname})
 992
 993     from(
 994       a in Activity,
 995       where: ^old_follower_address in a.recipients,
 996       update: [
 997         set: [
 998           recipients:
 999             fragment(
1000               "array_replace(?,?,?)",
1001               a.recipients,
1002               ^old_follower_address,
1003               ^user.follower_address
1004             )
1005         ]
1006       ]
1007     )
1008     |> Repo.update_all([])
1009   end
1010
1011   def upgrade_user_from_ap_id(ap_id) do
1012     with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1013          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1014          {:ok, user} <- update_user(user, data) do
1015       TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1016       {:ok, user}
1017     else
1018       %User{} = user -> {:ok, user}
1019       e -> e
1020     end
1021   end
1022
1023   defp update_user(user, data) do
1024     user
1025     |> User.remote_user_changeset(data)
1026     |> User.update_and_set_cache()
1027   end
1028
1029   def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1030     Map.put(data, "url", url["href"])
1031   end
1032
1033   def maybe_fix_user_url(data), do: data
1034
1035   def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
1036 end