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