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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 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.FollowingRelationship
  11   alias Pleroma.Object
  12   alias Pleroma.Object.Containment
  13   alias Pleroma.Repo
  14   alias Pleroma.User
  15   alias Pleroma.Web.ActivityPub.ActivityPub
  16   alias Pleroma.Web.ActivityPub.ObjectValidator
  17   alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
  18   alias Pleroma.Web.ActivityPub.Pipeline
  19   alias Pleroma.Web.ActivityPub.Utils
  20   alias Pleroma.Web.ActivityPub.Visibility
  21   alias Pleroma.Web.Federator
  22   alias Pleroma.Workers.TransmogrifierWorker
  23
  24   import Ecto.Query
  25
  26   require Logger
  27   require Pleroma.Constants
  28
  29   @doc """
  30   Modifies an incoming AP object (mastodon format) to our internal format.
  31   """
  32   def fix_object(object, options \\ []) do
  33     object
  34     |> strip_internal_fields
  35     |> fix_actor
  36     |> fix_url
  37     |> fix_attachments
  38     |> fix_context
  39     |> fix_in_reply_to(options)
  40     |> fix_emoji
  41     |> fix_tag
  42     |> fix_content_map
  43     |> fix_addressing
  44     |> fix_summary
  45     |> fix_type(options)
  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     cond do
  61       is_binary(map[field]) ->
  62         Map.put(map, field, [map[field]])
  63
  64       is_nil(map[field]) ->
  65         Map.put(map, field, [])
  66
  67       true ->
  68         map
  69     end
  70   end
  71
  72   def fix_explicit_addressing(
  73         %{"to" => to, "cc" => cc} = object,
  74         explicit_mentions,
  75         follower_collection
  76       ) do
  77     explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
  78
  79     explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
  80
  81     final_cc =
  82       (cc ++ explicit_cc)
  83       |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
  84       |> Enum.uniq()
  85
  86     object
  87     |> Map.put("to", explicit_to)
  88     |> Map.put("cc", final_cc)
  89   end
  90
  91   def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
  92
  93   # if directMessage flag is set to true, leave the addressing alone
  94   def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
  95
  96   def fix_explicit_addressing(object) do
  97     explicit_mentions = Utils.determine_explicit_mentions(object)
  98
  99     %User{follower_address: follower_collection} =
 100       object
 101       |> Containment.get_actor()
 102       |> User.get_cached_by_ap_id()
 103
 104     explicit_mentions =
 105       explicit_mentions ++
 106         [
 107           Pleroma.Constants.as_public(),
 108           follower_collection
 109         ]
 110
 111     fix_explicit_addressing(object, explicit_mentions, follower_collection)
 112   end
 113
 114   # if as:Public is addressed, then make sure the followers collection is also addressed
 115   # so that the activities will be delivered to local users.
 116   def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
 117     recipients = to ++ cc
 118
 119     if followers_collection not in recipients do
 120       cond do
 121         Pleroma.Constants.as_public() in cc ->
 122           to = to ++ [followers_collection]
 123           Map.put(object, "to", to)
 124
 125         Pleroma.Constants.as_public() in to ->
 126           cc = cc ++ [followers_collection]
 127           Map.put(object, "cc", cc)
 128
 129         true ->
 130           object
 131       end
 132     else
 133       object
 134     end
 135   end
 136
 137   def fix_implicit_addressing(object, _), do: object
 138
 139   def fix_addressing(object) do
 140     {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
 141     followers_collection = User.ap_followers(user)
 142
 143     object
 144     |> fix_addressing_list("to")
 145     |> fix_addressing_list("cc")
 146     |> fix_addressing_list("bto")
 147     |> fix_addressing_list("bcc")
 148     |> fix_explicit_addressing()
 149     |> fix_implicit_addressing(followers_collection)
 150   end
 151
 152   def fix_actor(%{"attributedTo" => actor} = object) do
 153     Map.put(object, "actor", Containment.get_actor(%{"actor" => actor}))
 154   end
 155
 156   def fix_in_reply_to(object, options \\ [])
 157
 158   def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
 159       when not is_nil(in_reply_to) do
 160     in_reply_to_id = prepare_in_reply_to(in_reply_to)
 161     object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
 162     depth = (options[:depth] || 0) + 1
 163
 164     if Federator.allowed_thread_distance?(depth) do
 165       with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
 166            %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
 167         object
 168         |> Map.put("inReplyTo", replied_object.data["id"])
 169         |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
 170         |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
 171         |> Map.put("context", replied_object.data["context"] || object["conversation"])
 172       else
 173         e ->
 174           Logger.error("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
 175           object
 176       end
 177     else
 178       object
 179     end
 180   end
 181
 182   def fix_in_reply_to(object, _options), do: object
 183
 184   defp prepare_in_reply_to(in_reply_to) do
 185     cond do
 186       is_bitstring(in_reply_to) ->
 187         in_reply_to
 188
 189       is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
 190         in_reply_to["id"]
 191
 192       is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
 193         Enum.at(in_reply_to, 0)
 194
 195       true ->
 196         ""
 197     end
 198   end
 199
 200   def fix_context(object) do
 201     context = object["context"] || object["conversation"] || Utils.generate_context_id()
 202
 203     object
 204     |> Map.put("context", context)
 205     |> Map.put("conversation", context)
 206   end
 207
 208   defp add_if_present(map, _key, nil), do: map
 209
 210   defp add_if_present(map, key, value) do
 211     Map.put(map, key, value)
 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) && is_binary(url["mediaType"]) -> url["mediaType"]
 227             is_binary(data["mediaType"]) -> data["mediaType"]
 228             is_binary(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           end
 238
 239         attachment_url =
 240           %{"href" => href}
 241           |> add_if_present("mediaType", media_type)
 242           |> add_if_present("type", Map.get(url || %{}, "type"))
 243
 244         %{"url" => [attachment_url]}
 245         |> add_if_present("mediaType", media_type)
 246         |> add_if_present("type", data["type"])
 247         |> add_if_present("name", data["name"])
 248       end)
 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(%{"type" => object_type, "url" => url} = object)
 266       when object_type in ["Video", "Audio"] and is_list(url) do
 267     first_element = Enum.at(url, 0)
 268
 269     link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)
 270
 271     object
 272     |> Map.put("attachment", [first_element])
 273     |> Map.put("url", link_element["href"])
 274   end
 275
 276   def fix_url(%{"type" => object_type, "url" => url} = object)
 277       when object_type != "Video" and is_list(url) do
 278     first_element = Enum.at(url, 0)
 279
 280     url_string =
 281       cond do
 282         is_bitstring(first_element) -> first_element
 283         is_map(first_element) -> first_element["href"] || ""
 284         true -> ""
 285       end
 286
 287     Map.put(object, "url", url_string)
 288   end
 289
 290   def fix_url(object), do: object
 291
 292   def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
 293     emoji =
 294       tags
 295       |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
 296       |> Enum.reduce(%{}, fn data, mapping ->
 297         name = String.trim(data["name"], ":")
 298
 299         Map.put(mapping, name, data["icon"]["url"])
 300       end)
 301
 302     # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
 303     emoji = Map.merge(object["emoji"] || %{}, emoji)
 304
 305     Map.put(object, "emoji", emoji)
 306   end
 307
 308   def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
 309     name = String.trim(tag["name"], ":")
 310     emoji = %{name => tag["icon"]["url"]}
 311
 312     Map.put(object, "emoji", emoji)
 313   end
 314
 315   def fix_emoji(object), do: object
 316
 317   def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
 318     tags =
 319       tag
 320       |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
 321       |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
 322
 323     Map.put(object, "tag", tag ++ tags)
 324   end
 325
 326   def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
 327     combined = [tag, String.slice(hashtag, 1..-1)]
 328
 329     Map.put(object, "tag", combined)
 330   end
 331
 332   def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
 333
 334   def fix_tag(object), do: object
 335
 336   # content map usually only has one language so this will do for now.
 337   def fix_content_map(%{"contentMap" => content_map} = object) do
 338     content_groups = Map.to_list(content_map)
 339     {_, content} = Enum.at(content_groups, 0)
 340
 341     Map.put(object, "content", content)
 342   end
 343
 344   def fix_content_map(object), do: object
 345
 346   def fix_type(object, options \\ [])
 347
 348   def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
 349       when is_binary(reply_id) do
 350     with true <- Federator.allowed_thread_distance?(options[:depth]),
 351          {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
 352       Map.put(object, "type", "Answer")
 353     else
 354       _ -> object
 355     end
 356   end
 357
 358   def fix_type(object, _), do: object
 359
 360   defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
 361     with true <- id =~ "follows",
 362          %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
 363          %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
 364       {:ok, activity}
 365     else
 366       _ -> {:error, nil}
 367     end
 368   end
 369
 370   defp mastodon_follow_hack(_, _), do: {:error, nil}
 371
 372   defp get_follow_activity(follow_object, followed) do
 373     with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
 374          {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
 375       {:ok, activity}
 376     else
 377       # Can't find the activity. This might a Mastodon 2.3 "Accept"
 378       {:activity, nil} ->
 379         mastodon_follow_hack(follow_object, followed)
 380
 381       _ ->
 382         {:error, nil}
 383     end
 384   end
 385
 386   # Reduce the object list to find the reported user.
 387   defp get_reported(objects) do
 388     Enum.reduce_while(objects, nil, fn ap_id, _ ->
 389       with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
 390         {:halt, user}
 391       else
 392         _ -> {:cont, nil}
 393       end
 394     end)
 395   end
 396
 397   def handle_incoming(data, options \\ [])
 398
 399   # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
 400   # with nil ID.
 401   def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
 402     with context <- data["context"] || Utils.generate_context_id(),
 403          content <- data["content"] || "",
 404          %User{} = actor <- User.get_cached_by_ap_id(actor),
 405          # Reduce the object list to find the reported user.
 406          %User{} = account <- get_reported(objects),
 407          # Remove the reported user from the object list.
 408          statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
 409       %{
 410         actor: actor,
 411         context: context,
 412         account: account,
 413         statuses: statuses,
 414         content: content,
 415         additional: %{"cc" => [account.ap_id]}
 416       }
 417       |> ActivityPub.flag()
 418     end
 419   end
 420
 421   # disallow objects with bogus IDs
 422   def handle_incoming(%{"id" => nil}, _options), do: :error
 423   def handle_incoming(%{"id" => ""}, _options), do: :error
 424   # length of https:// = 8, should validate better, but good enough for now.
 425   def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
 426     do: :error
 427
 428   # TODO: validate those with a Ecto scheme
 429   # - tags
 430   # - emoji
 431   def handle_incoming(
 432         %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
 433         options
 434       )
 435       when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer", "Audio"] do
 436     actor = Containment.get_actor(data)
 437
 438     data =
 439       Map.put(data, "actor", actor)
 440       |> fix_addressing
 441
 442     with nil <- Activity.get_create_by_object_ap_id(object["id"]),
 443          {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
 444       object = fix_object(object, options)
 445
 446       params = %{
 447         to: data["to"],
 448         object: object,
 449         actor: user,
 450         context: object["conversation"],
 451         local: false,
 452         published: data["published"],
 453         additional:
 454           Map.take(data, [
 455             "cc",
 456             "directMessage",
 457             "id"
 458           ])
 459       }
 460
 461       with {:ok, created_activity} <- ActivityPub.create(params) do
 462         reply_depth = (options[:depth] || 0) + 1
 463
 464         if Federator.allowed_thread_distance?(reply_depth) do
 465           for reply_id <- replies(object) do
 466             Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
 467               "id" => reply_id,
 468               "depth" => reply_depth
 469             })
 470           end
 471         end
 472
 473         {:ok, created_activity}
 474       end
 475     else
 476       %Activity{} = activity -> {:ok, activity}
 477       _e -> :error
 478     end
 479   end
 480
 481   def handle_incoming(
 482         %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
 483         options
 484       ) do
 485     actor = Containment.get_actor(data)
 486
 487     data =
 488       Map.put(data, "actor", actor)
 489       |> fix_addressing
 490
 491     with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
 492       reply_depth = (options[:depth] || 0) + 1
 493       options = Keyword.put(options, :depth, reply_depth)
 494       object = fix_object(object, options)
 495
 496       params = %{
 497         to: data["to"],
 498         object: object,
 499         actor: user,
 500         context: nil,
 501         local: false,
 502         published: data["published"],
 503         additional: Map.take(data, ["cc", "id"])
 504       }
 505
 506       ActivityPub.listen(params)
 507     else
 508       _e -> :error
 509     end
 510   end
 511
 512   def handle_incoming(
 513         %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
 514         _options
 515       ) do
 516     with %User{local: true} = followed <-
 517            User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
 518          {:ok, %User{} = follower} <-
 519            User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
 520          {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
 521       with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
 522            {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
 523            {_, false} <- {:user_locked, User.locked?(followed)},
 524            {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
 525            {_, {:ok, _}} <-
 526              {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
 527            {:ok, _relationship} <-
 528              FollowingRelationship.update(follower, followed, :follow_accept) do
 529         ActivityPub.accept(%{
 530           to: [follower.ap_id],
 531           actor: followed,
 532           object: data,
 533           local: true
 534         })
 535       else
 536         {:user_blocked, true} ->
 537           {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
 538           {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
 539
 540           ActivityPub.reject(%{
 541             to: [follower.ap_id],
 542             actor: followed,
 543             object: data,
 544             local: true
 545           })
 546
 547         {:follow, {:error, _}} ->
 548           {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
 549           {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
 550
 551           ActivityPub.reject(%{
 552             to: [follower.ap_id],
 553             actor: followed,
 554             object: data,
 555             local: true
 556           })
 557
 558         {:user_locked, true} ->
 559           {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_pending)
 560           :noop
 561       end
 562
 563       {:ok, activity}
 564     else
 565       _e ->
 566         :error
 567     end
 568   end
 569
 570   def handle_incoming(
 571         %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
 572         _options
 573       ) do
 574     with actor <- Containment.get_actor(data),
 575          {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
 576          {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
 577          {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
 578          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
 579          {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
 580       ActivityPub.accept(%{
 581         to: follow_activity.data["to"],
 582         type: "Accept",
 583         actor: followed,
 584         object: follow_activity.data["id"],
 585         local: false,
 586         activity_id: id
 587       })
 588     else
 589       _e -> :error
 590     end
 591   end
 592
 593   def handle_incoming(
 594         %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
 595         _options
 596       ) do
 597     with actor <- Containment.get_actor(data),
 598          {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
 599          {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
 600          {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
 601          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
 602          {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
 603          {:ok, activity} <-
 604            ActivityPub.reject(%{
 605              to: follow_activity.data["to"],
 606              type: "Reject",
 607              actor: followed,
 608              object: follow_activity.data["id"],
 609              local: false,
 610              activity_id: id
 611            }) do
 612       {:ok, activity}
 613     else
 614       _e -> :error
 615     end
 616   end
 617
 618   @misskey_reactions %{
 619     "like" => "👍",
 620     "love" => "❤️",
 621     "laugh" => "😆",
 622     "hmm" => "🤔",
 623     "surprise" => "😮",
 624     "congrats" => "🎉",
 625     "angry" => "💢",
 626     "confused" => "😥",
 627     "rip" => "😇",
 628     "pudding" => "🍮",
 629     "star" => "⭐"
 630   }
 631
 632   @doc "Rewrite misskey likes into EmojiReacts"
 633   def handle_incoming(
 634         %{
 635           "type" => "Like",
 636           "_misskey_reaction" => reaction
 637         } = data,
 638         options
 639       ) do
 640     data
 641     |> Map.put("type", "EmojiReact")
 642     |> Map.put("content", @misskey_reactions[reaction] || reaction)
 643     |> handle_incoming(options)
 644   end
 645
 646   def handle_incoming(
 647         %{"type" => "Create", "object" => %{"type" => "ChatMessage"}} = data,
 648         _options
 649       ) do
 650     with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
 651          {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
 652       {:ok, activity}
 653     end
 654   end
 655
 656   def handle_incoming(%{"type" => "Like"} = data, _options) do
 657     with {_, {:ok, cast_data_sym}} <-
 658            {:casting_data,
 659             data |> LikeValidator.cast_data() |> Ecto.Changeset.apply_action(:insert)},
 660          cast_data = ObjectValidator.stringify_keys(Map.from_struct(cast_data_sym)),
 661          :ok <- ObjectValidator.fetch_actor_and_object(cast_data),
 662          {_, {:ok, cast_data}} <- {:ensure_context_presence, ensure_context_presence(cast_data)},
 663          {_, {:ok, cast_data}} <-
 664            {:ensure_recipients_presence, ensure_recipients_presence(cast_data)},
 665          {_, {:ok, activity, _meta}} <-
 666            {:common_pipeline, Pipeline.common_pipeline(cast_data, local: false)} do
 667       {:ok, activity}
 668     else
 669       e -> {:error, e}
 670     end
 671   end
 672
 673   def handle_incoming(
 674         %{
 675           "type" => "EmojiReact",
 676           "object" => object_id,
 677           "actor" => _actor,
 678           "id" => id,
 679           "content" => emoji
 680         } = data,
 681         _options
 682       ) do
 683     with actor <- Containment.get_actor(data),
 684          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 685          {:ok, object} <- get_obj_helper(object_id),
 686          {:ok, activity, _object} <-
 687            ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
 688       {:ok, activity}
 689     else
 690       _e -> :error
 691     end
 692   end
 693
 694   def handle_incoming(
 695         %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
 696         _options
 697       ) do
 698     with actor <- Containment.get_actor(data),
 699          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 700          {:ok, object} <- get_embedded_obj_helper(object_id, actor),
 701          public <- Visibility.is_public?(data),
 702          {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
 703       {:ok, activity}
 704     else
 705       _e -> :error
 706     end
 707   end
 708
 709   def handle_incoming(
 710         %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
 711           data,
 712         _options
 713       )
 714       when object_type in [
 715              "Person",
 716              "Application",
 717              "Service",
 718              "Organization"
 719            ] do
 720     with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
 721       {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
 722
 723       actor
 724       |> User.remote_user_changeset(new_user_data)
 725       |> User.update_and_set_cache()
 726
 727       ActivityPub.update(%{
 728         local: false,
 729         to: data["to"] || [],
 730         cc: data["cc"] || [],
 731         object: object,
 732         actor: actor_id,
 733         activity_id: data["id"]
 734       })
 735     else
 736       e ->
 737         Logger.error(e)
 738         :error
 739     end
 740   end
 741
 742   # TODO: We presently assume that any actor on the same origin domain as the object being
 743   # deleted has the rights to delete that object.  A better way to validate whether or not
 744   # the object should be deleted is to refetch the object URI, which should return either
 745   # an error or a tombstone.  This would allow us to verify that a deletion actually took
 746   # place.
 747   def handle_incoming(
 748         %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
 749         _options
 750       ) do
 751     object_id = Utils.get_ap_id(object_id)
 752
 753     with actor <- Containment.get_actor(data),
 754          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 755          {:ok, object} <- get_obj_helper(object_id),
 756          :ok <- Containment.contain_origin(actor.ap_id, object.data),
 757          {:ok, activity} <-
 758            ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
 759       {:ok, activity}
 760     else
 761       nil ->
 762         case User.get_cached_by_ap_id(object_id) do
 763           %User{ap_id: ^actor} = user ->
 764             User.delete(user)
 765
 766           nil ->
 767             :error
 768         end
 769
 770       _e ->
 771         :error
 772     end
 773   end
 774
 775   def handle_incoming(
 776         %{
 777           "type" => "Undo",
 778           "object" => %{"type" => "Announce", "object" => object_id},
 779           "actor" => _actor,
 780           "id" => id
 781         } = data,
 782         _options
 783       ) do
 784     with actor <- Containment.get_actor(data),
 785          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 786          {:ok, object} <- get_obj_helper(object_id),
 787          {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
 788       {:ok, activity}
 789     else
 790       _e -> :error
 791     end
 792   end
 793
 794   def handle_incoming(
 795         %{
 796           "type" => "Undo",
 797           "object" => %{"type" => "Follow", "object" => followed},
 798           "actor" => follower,
 799           "id" => id
 800         } = _data,
 801         _options
 802       ) do
 803     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 804          {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
 805          {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
 806       User.unfollow(follower, followed)
 807       {:ok, activity}
 808     else
 809       _e -> :error
 810     end
 811   end
 812
 813   def handle_incoming(
 814         %{
 815           "type" => "Undo",
 816           "object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
 817           "actor" => _actor,
 818           "id" => id
 819         } = data,
 820         _options
 821       ) do
 822     with actor <- Containment.get_actor(data),
 823          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 824          {:ok, activity, _} <-
 825            ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
 826              activity_id: id,
 827              local: false
 828            ) do
 829       {:ok, activity}
 830     else
 831       _e -> :error
 832     end
 833   end
 834
 835   def handle_incoming(
 836         %{
 837           "type" => "Undo",
 838           "object" => %{"type" => "Block", "object" => blocked},
 839           "actor" => blocker,
 840           "id" => id
 841         } = _data,
 842         _options
 843       ) do
 844     with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
 845          {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
 846          {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
 847       User.unblock(blocker, blocked)
 848       {:ok, activity}
 849     else
 850       _e -> :error
 851     end
 852   end
 853
 854   def handle_incoming(
 855         %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
 856         _options
 857       ) do
 858     with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
 859          {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
 860          {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
 861       User.unfollow(blocker, blocked)
 862       User.block(blocker, blocked)
 863       {:ok, activity}
 864     else
 865       _e -> :error
 866     end
 867   end
 868
 869   def handle_incoming(
 870         %{
 871           "type" => "Undo",
 872           "object" => %{"type" => "Like", "object" => object_id},
 873           "actor" => _actor,
 874           "id" => id
 875         } = data,
 876         _options
 877       ) do
 878     with actor <- Containment.get_actor(data),
 879          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 880          {:ok, object} <- get_obj_helper(object_id),
 881          {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
 882       {:ok, activity}
 883     else
 884       _e -> :error
 885     end
 886   end
 887
 888   # For Undos that don't have the complete object attached, try to find it in our database.
 889   def handle_incoming(
 890         %{
 891           "type" => "Undo",
 892           "object" => object
 893         } = activity,
 894         options
 895       )
 896       when is_binary(object) do
 897     with %Activity{data: data} <- Activity.get_by_ap_id(object) do
 898       activity
 899       |> Map.put("object", data)
 900       |> handle_incoming(options)
 901     else
 902       _e -> :error
 903     end
 904   end
 905
 906   def handle_incoming(
 907         %{
 908           "type" => "Move",
 909           "actor" => origin_actor,
 910           "object" => origin_actor,
 911           "target" => target_actor
 912         },
 913         _options
 914       ) do
 915     with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
 916          {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
 917          true <- origin_actor in target_user.also_known_as do
 918       ActivityPub.move(origin_user, target_user, false)
 919     else
 920       _e -> :error
 921     end
 922   end
 923
 924   def handle_incoming(_, _), do: :error
 925
 926   @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
 927   def get_obj_helper(id, options \\ []) do
 928     case Object.normalize(id, true, options) do
 929       %Object{} = object -> {:ok, object}
 930       _ -> nil
 931     end
 932   end
 933
 934   @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
 935   def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
 936         ap_id: ap_id
 937       })
 938       when attributed_to == ap_id do
 939     with {:ok, activity} <-
 940            handle_incoming(%{
 941              "type" => "Create",
 942              "to" => data["to"],
 943              "cc" => data["cc"],
 944              "actor" => attributed_to,
 945              "object" => data
 946            }) do
 947       {:ok, Object.normalize(activity)}
 948     else
 949       _ -> get_obj_helper(object_id)
 950     end
 951   end
 952
 953   def get_embedded_obj_helper(object_id, _) do
 954     get_obj_helper(object_id)
 955   end
 956
 957   def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
 958     with false <- String.starts_with?(in_reply_to, "http"),
 959          {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
 960       Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
 961     else
 962       _e -> object
 963     end
 964   end
 965
 966   def set_reply_to_uri(obj), do: obj
 967
 968   @doc """
 969   Serialized Mastodon-compatible `replies` collection containing _self-replies_.
 970   Based on Mastodon's ActivityPub::NoteSerializer#replies.
 971   """
 972   def set_replies(obj_data) do
 973     replies_uris =
 974       with limit when limit > 0 <-
 975              Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
 976            %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
 977         object
 978         |> Object.self_replies()
 979         |> select([o], fragment("?->>'id'", o.data))
 980         |> limit(^limit)
 981         |> Repo.all()
 982       else
 983         _ -> []
 984       end
 985
 986     set_replies(obj_data, replies_uris)
 987   end
 988
 989   defp set_replies(obj, []) do
 990     obj
 991   end
 992
 993   defp set_replies(obj, replies_uris) do
 994     replies_collection = %{
 995       "type" => "Collection",
 996       "items" => replies_uris
 997     }
 998
 999     Map.merge(obj, %{"replies" => replies_collection})
1000   end
1001
1002   def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
1003     items
1004   end
1005
1006   def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
1007     items
1008   end
1009
1010   def replies(_), do: []
1011
1012   # Prepares the object of an outgoing create activity.
1013   def prepare_object(object) do
1014     object
1015     |> set_sensitive
1016     |> add_hashtags
1017     |> add_mention_tags
1018     |> add_emoji_tags
1019     |> add_attributed_to
1020     |> prepare_attachments
1021     |> set_conversation
1022     |> set_reply_to_uri
1023     |> set_replies
1024     |> strip_internal_fields
1025     |> strip_internal_tags
1026     |> set_type
1027   end
1028
1029   #  @doc
1030   #  """
1031   #  internal -> Mastodon
1032   #  """
1033
1034   def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
1035       when activity_type in ["Create", "Listen"] do
1036     object =
1037       object_id
1038       |> Object.normalize()
1039       |> Map.get(:data)
1040       |> prepare_object
1041
1042     data =
1043       data
1044       |> Map.put("object", object)
1045       |> Map.merge(Utils.make_json_ld_header())
1046       |> Map.delete("bcc")
1047
1048     {:ok, data}
1049   end
1050
1051   def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
1052     object =
1053       object_id
1054       |> Object.normalize()
1055
1056     data =
1057       if Visibility.is_private?(object) && object.data["actor"] == ap_id do
1058         data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
1059       else
1060         data |> maybe_fix_object_url
1061       end
1062
1063     data =
1064       data
1065       |> strip_internal_fields
1066       |> Map.merge(Utils.make_json_ld_header())
1067       |> Map.delete("bcc")
1068
1069     {:ok, data}
1070   end
1071
1072   # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
1073   # because of course it does.
1074   def prepare_outgoing(%{"type" => "Accept"} = data) do
1075     with follow_activity <- Activity.normalize(data["object"]) do
1076       object = %{
1077         "actor" => follow_activity.actor,
1078         "object" => follow_activity.data["object"],
1079         "id" => follow_activity.data["id"],
1080         "type" => "Follow"
1081       }
1082
1083       data =
1084         data
1085         |> Map.put("object", object)
1086         |> Map.merge(Utils.make_json_ld_header())
1087
1088       {:ok, data}
1089     end
1090   end
1091
1092   def prepare_outgoing(%{"type" => "Reject"} = data) do
1093     with follow_activity <- Activity.normalize(data["object"]) do
1094       object = %{
1095         "actor" => follow_activity.actor,
1096         "object" => follow_activity.data["object"],
1097         "id" => follow_activity.data["id"],
1098         "type" => "Follow"
1099       }
1100
1101       data =
1102         data
1103         |> Map.put("object", object)
1104         |> Map.merge(Utils.make_json_ld_header())
1105
1106       {:ok, data}
1107     end
1108   end
1109
1110   def prepare_outgoing(%{"type" => _type} = data) do
1111     data =
1112       data
1113       |> strip_internal_fields
1114       |> maybe_fix_object_url
1115       |> Map.merge(Utils.make_json_ld_header())
1116
1117     {:ok, data}
1118   end
1119
1120   def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
1121     with false <- String.starts_with?(object, "http"),
1122          {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
1123          %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
1124            relative_object do
1125       Map.put(data, "object", external_url)
1126     else
1127       {:fetch, e} ->
1128         Logger.error("Couldn't fetch #{object} #{inspect(e)}")
1129         data
1130
1131       _ ->
1132         data
1133     end
1134   end
1135
1136   def maybe_fix_object_url(data), do: data
1137
1138   def add_hashtags(object) do
1139     tags =
1140       (object["tag"] || [])
1141       |> Enum.map(fn
1142         # Expand internal representation tags into AS2 tags.
1143         tag when is_binary(tag) ->
1144           %{
1145             "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
1146             "name" => "##{tag}",
1147             "type" => "Hashtag"
1148           }
1149
1150         # Do not process tags which are already AS2 tag objects.
1151         tag when is_map(tag) ->
1152           tag
1153       end)
1154
1155     Map.put(object, "tag", tags)
1156   end
1157
1158   def add_mention_tags(object) do
1159     {enabled_receivers, disabled_receivers} = Utils.get_notified_from_object(object)
1160     potential_receivers = enabled_receivers ++ disabled_receivers
1161     mentions = Enum.map(potential_receivers, &build_mention_tag/1)
1162
1163     tags = object["tag"] || []
1164     Map.put(object, "tag", tags ++ mentions)
1165   end
1166
1167   defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1168     %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1169   end
1170
1171   def take_emoji_tags(%User{emoji: emoji}) do
1172     emoji
1173     |> Map.to_list()
1174     |> Enum.map(&build_emoji_tag/1)
1175   end
1176
1177   # TODO: we should probably send mtime instead of unix epoch time for updated
1178   def add_emoji_tags(%{"emoji" => emoji} = object) do
1179     tags = object["tag"] || []
1180
1181     out = Enum.map(emoji, &build_emoji_tag/1)
1182
1183     Map.put(object, "tag", tags ++ out)
1184   end
1185
1186   def add_emoji_tags(object), do: object
1187
1188   defp build_emoji_tag({name, url}) do
1189     %{
1190       "icon" => %{"url" => url, "type" => "Image"},
1191       "name" => ":" <> name <> ":",
1192       "type" => "Emoji",
1193       "updated" => "1970-01-01T00:00:00Z",
1194       "id" => url
1195     }
1196   end
1197
1198   def set_conversation(object) do
1199     Map.put(object, "conversation", object["context"])
1200   end
1201
1202   def set_sensitive(object) do
1203     tags = object["tag"] || []
1204     Map.put(object, "sensitive", "nsfw" in tags)
1205   end
1206
1207   def set_type(%{"type" => "Answer"} = object) do
1208     Map.put(object, "type", "Note")
1209   end
1210
1211   def set_type(object), do: object
1212
1213   def add_attributed_to(object) do
1214     attributed_to = object["attributedTo"] || object["actor"]
1215     Map.put(object, "attributedTo", attributed_to)
1216   end
1217
1218   def prepare_attachments(object) do
1219     attachments =
1220       (object["attachment"] || [])
1221       |> Enum.map(fn data ->
1222         [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1223         %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1224       end)
1225
1226     Map.put(object, "attachment", attachments)
1227   end
1228
1229   def strip_internal_fields(object) do
1230     object
1231     |> Map.drop(Pleroma.Constants.object_internal_fields())
1232   end
1233
1234   defp strip_internal_tags(%{"tag" => tags} = object) do
1235     tags = Enum.filter(tags, fn x -> is_map(x) end)
1236
1237     Map.put(object, "tag", tags)
1238   end
1239
1240   defp strip_internal_tags(object), do: object
1241
1242   def perform(:user_upgrade, user) do
1243     # we pass a fake user so that the followers collection is stripped away
1244     old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1245
1246     from(
1247       a in Activity,
1248       where: ^old_follower_address in a.recipients,
1249       update: [
1250         set: [
1251           recipients:
1252             fragment(
1253               "array_replace(?,?,?)",
1254               a.recipients,
1255               ^old_follower_address,
1256               ^user.follower_address
1257             )
1258         ]
1259       ]
1260     )
1261     |> Repo.update_all([])
1262   end
1263
1264   def upgrade_user_from_ap_id(ap_id) do
1265     with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1266          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1267          {:ok, user} <- update_user(user, data) do
1268       TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1269       {:ok, user}
1270     else
1271       %User{} = user -> {:ok, user}
1272       e -> e
1273     end
1274   end
1275
1276   defp update_user(user, data) do
1277     user
1278     |> User.remote_user_changeset(data)
1279     |> User.update_and_set_cache()
1280   end
1281
1282   def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1283     Map.put(data, "url", url["href"])
1284   end
1285
1286   def maybe_fix_user_url(data), do: data
1287
1288   def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
1289
1290   defp ensure_context_presence(%{"context" => context} = data) when is_binary(context),
1291     do: {:ok, data}
1292
1293   defp ensure_context_presence(%{"object" => object} = data) when is_binary(object) do
1294     with %{data: %{"context" => context}} when is_binary(context) <- Object.normalize(object) do
1295       {:ok, Map.put(data, "context", context)}
1296     else
1297       _ ->
1298         {:error, :no_context}
1299     end
1300   end
1301
1302   defp ensure_context_presence(_) do
1303     {:error, :no_context}
1304   end
1305
1306   defp ensure_recipients_presence(%{"to" => [_ | _], "cc" => [_ | _]} = data),
1307     do: {:ok, data}
1308
1309   defp ensure_recipients_presence(%{"object" => object} = data) do
1310     case Object.normalize(object) do
1311       %{data: %{"actor" => actor}} ->
1312         data =
1313           data
1314           |> Map.put("to", [actor])
1315           |> Map.put("cc", data["cc"] || [])
1316
1317         {:ok, data}
1318
1319       nil ->
1320         {:error, :no_object}
1321
1322       _ ->
1323         {:error, :no_actor}
1324     end
1325   end
1326
1327   defp ensure_recipients_presence(_) do
1328     {:error, :no_object}
1329   end
1330 end