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