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