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