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

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