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