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