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} <- FollowingRelationship.update(follower, followed, "accept") do
 495         ActivityPub.accept(%{
 496           to: [follower.ap_id],
 497           actor: followed,
 498           object: data,
 499           local: true
 500         })
 501       else
 502         {:user_blocked, true} ->
 503           {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
 504           {:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")
 505
 506           ActivityPub.reject(%{
 507             to: [follower.ap_id],
 508             actor: followed,
 509             object: data,
 510             local: true
 511           })
 512
 513         {:follow, {:error, _}} ->
 514           {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
 515           {:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")
 516
 517           ActivityPub.reject(%{
 518             to: [follower.ap_id],
 519             actor: followed,
 520             object: data,
 521             local: true
 522           })
 523
 524         {:user_locked, true} ->
 525           {:ok, _relationship} = FollowingRelationship.update(follower, followed, "pending")
 526           :noop
 527       end
 528
 529       {:ok, activity}
 530     else
 531       _e ->
 532         :error
 533     end
 534   end
 535
 536   def handle_incoming(
 537         %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
 538         _options
 539       ) do
 540     with actor <- Containment.get_actor(data),
 541          {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
 542          {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
 543          {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
 544          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
 545          {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do
 546       ActivityPub.accept(%{
 547         to: follow_activity.data["to"],
 548         type: "Accept",
 549         actor: followed,
 550         object: follow_activity.data["id"],
 551         local: false,
 552         activity_id: id
 553       })
 554     else
 555       _e -> :error
 556     end
 557   end
 558
 559   def handle_incoming(
 560         %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
 561         _options
 562       ) do
 563     with actor <- Containment.get_actor(data),
 564          {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
 565          {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
 566          {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
 567          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
 568          {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "reject"),
 569          {:ok, activity} <-
 570            ActivityPub.reject(%{
 571              to: follow_activity.data["to"],
 572              type: "Reject",
 573              actor: followed,
 574              object: follow_activity.data["id"],
 575              local: false,
 576              activity_id: id
 577            }) do
 578       {:ok, activity}
 579     else
 580       _e -> :error
 581     end
 582   end
 583
 584   @misskey_reactions %{
 585     "like" => "👍",
 586     "love" => "❤️",
 587     "laugh" => "😆",
 588     "hmm" => "🤔",
 589     "surprise" => "😮",
 590     "congrats" => "🎉",
 591     "angry" => "💢",
 592     "confused" => "😥",
 593     "rip" => "😇",
 594     "pudding" => "🍮",
 595     "star" => "⭐"
 596   }
 597
 598   @doc "Rewrite misskey likes into EmojiReacts"
 599   def handle_incoming(
 600         %{
 601           "type" => "Like",
 602           "_misskey_reaction" => reaction
 603         } = data,
 604         options
 605       ) do
 606     data
 607     |> Map.put("type", "EmojiReact")
 608     |> Map.put("content", @misskey_reactions[reaction] || reaction)
 609     |> handle_incoming(options)
 610   end
 611
 612   def handle_incoming(
 613         %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data,
 614         _options
 615       ) do
 616     with actor <- Containment.get_actor(data),
 617          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 618          {:ok, object} <- get_obj_helper(object_id),
 619          {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
 620       {:ok, activity}
 621     else
 622       _e -> :error
 623     end
 624   end
 625
 626   def handle_incoming(
 627         %{
 628           "type" => "EmojiReact",
 629           "object" => object_id,
 630           "actor" => _actor,
 631           "id" => id,
 632           "content" => emoji
 633         } = data,
 634         _options
 635       ) do
 636     with actor <- Containment.get_actor(data),
 637          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 638          {:ok, object} <- get_obj_helper(object_id),
 639          {:ok, activity, _object} <-
 640            ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
 641       {:ok, activity}
 642     else
 643       _e -> :error
 644     end
 645   end
 646
 647   def handle_incoming(
 648         %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
 649         _options
 650       ) do
 651     with actor <- Containment.get_actor(data),
 652          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 653          {:ok, object} <- get_embedded_obj_helper(object_id, actor),
 654          public <- Visibility.is_public?(data),
 655          {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
 656       {:ok, activity}
 657     else
 658       _e -> :error
 659     end
 660   end
 661
 662   def handle_incoming(
 663         %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
 664           data,
 665         _options
 666       )
 667       when object_type in [
 668              "Person",
 669              "Application",
 670              "Service",
 671              "Organization"
 672            ] do
 673     with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
 674       {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
 675
 676       actor
 677       |> User.upgrade_changeset(new_user_data, true)
 678       |> User.update_and_set_cache()
 679
 680       ActivityPub.update(%{
 681         local: false,
 682         to: data["to"] || [],
 683         cc: data["cc"] || [],
 684         object: object,
 685         actor: actor_id,
 686         activity_id: data["id"]
 687       })
 688     else
 689       e ->
 690         Logger.error(e)
 691         :error
 692     end
 693   end
 694
 695   # TODO: We presently assume that any actor on the same origin domain as the object being
 696   # deleted has the rights to delete that object.  A better way to validate whether or not
 697   # the object should be deleted is to refetch the object URI, which should return either
 698   # an error or a tombstone.  This would allow us to verify that a deletion actually took
 699   # place.
 700   def handle_incoming(
 701         %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
 702         _options
 703       ) do
 704     object_id = Utils.get_ap_id(object_id)
 705
 706     with actor <- Containment.get_actor(data),
 707          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 708          {:ok, object} <- get_obj_helper(object_id),
 709          :ok <- Containment.contain_origin(actor.ap_id, object.data),
 710          {:ok, activity} <-
 711            ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
 712       {:ok, activity}
 713     else
 714       nil ->
 715         case User.get_cached_by_ap_id(object_id) do
 716           %User{ap_id: ^actor} = user ->
 717             User.delete(user)
 718
 719           nil ->
 720             :error
 721         end
 722
 723       _e ->
 724         :error
 725     end
 726   end
 727
 728   def handle_incoming(
 729         %{
 730           "type" => "Undo",
 731           "object" => %{"type" => "Announce", "object" => object_id},
 732           "actor" => _actor,
 733           "id" => id
 734         } = data,
 735         _options
 736       ) do
 737     with actor <- Containment.get_actor(data),
 738          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 739          {:ok, object} <- get_obj_helper(object_id),
 740          {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
 741       {:ok, activity}
 742     else
 743       _e -> :error
 744     end
 745   end
 746
 747   def handle_incoming(
 748         %{
 749           "type" => "Undo",
 750           "object" => %{"type" => "Follow", "object" => followed},
 751           "actor" => follower,
 752           "id" => id
 753         } = _data,
 754         _options
 755       ) do
 756     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 757          {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
 758          {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
 759       User.unfollow(follower, followed)
 760       {:ok, activity}
 761     else
 762       _e -> :error
 763     end
 764   end
 765
 766   def handle_incoming(
 767         %{
 768           "type" => "Undo",
 769           "object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
 770           "actor" => _actor,
 771           "id" => id
 772         } = data,
 773         _options
 774       ) do
 775     with actor <- Containment.get_actor(data),
 776          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 777          {:ok, activity, _} <-
 778            ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
 779              activity_id: id,
 780              local: false
 781            ) do
 782       {:ok, activity}
 783     else
 784       _e -> :error
 785     end
 786   end
 787
 788   def handle_incoming(
 789         %{
 790           "type" => "Undo",
 791           "object" => %{"type" => "Block", "object" => blocked},
 792           "actor" => blocker,
 793           "id" => id
 794         } = _data,
 795         _options
 796       ) do
 797     with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
 798          {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
 799          {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
 800       User.unblock(blocker, blocked)
 801       {:ok, activity}
 802     else
 803       _e -> :error
 804     end
 805   end
 806
 807   def handle_incoming(
 808         %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
 809         _options
 810       ) do
 811     with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
 812          {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
 813          {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
 814       User.unfollow(blocker, blocked)
 815       User.block(blocker, blocked)
 816       {:ok, activity}
 817     else
 818       _e -> :error
 819     end
 820   end
 821
 822   def handle_incoming(
 823         %{
 824           "type" => "Undo",
 825           "object" => %{"type" => "Like", "object" => object_id},
 826           "actor" => _actor,
 827           "id" => id
 828         } = data,
 829         _options
 830       ) do
 831     with actor <- Containment.get_actor(data),
 832          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 833          {:ok, object} <- get_obj_helper(object_id),
 834          {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
 835       {:ok, activity}
 836     else
 837       _e -> :error
 838     end
 839   end
 840
 841   # For Undos that don't have the complete object attached, try to find it in our database.
 842   def handle_incoming(
 843         %{
 844           "type" => "Undo",
 845           "object" => object
 846         } = activity,
 847         options
 848       )
 849       when is_binary(object) do
 850     with %Activity{data: data} <- Activity.get_by_ap_id(object) do
 851       activity
 852       |> Map.put("object", data)
 853       |> handle_incoming(options)
 854     else
 855       _e -> :error
 856     end
 857   end
 858
 859   def handle_incoming(
 860         %{
 861           "type" => "Move",
 862           "actor" => origin_actor,
 863           "object" => origin_actor,
 864           "target" => target_actor
 865         },
 866         _options
 867       ) do
 868     with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
 869          {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
 870          true <- origin_actor in target_user.also_known_as do
 871       ActivityPub.move(origin_user, target_user, false)
 872     else
 873       _e -> :error
 874     end
 875   end
 876
 877   def handle_incoming(_, _), do: :error
 878
 879   @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
 880   def get_obj_helper(id, options \\ []) do
 881     case Object.normalize(id, true, options) do
 882       %Object{} = object -> {:ok, object}
 883       _ -> nil
 884     end
 885   end
 886
 887   @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
 888   def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
 889         ap_id: ap_id
 890       })
 891       when attributed_to == ap_id do
 892     with {:ok, activity} <-
 893            handle_incoming(%{
 894              "type" => "Create",
 895              "to" => data["to"],
 896              "cc" => data["cc"],
 897              "actor" => attributed_to,
 898              "object" => data
 899            }) do
 900       {:ok, Object.normalize(activity)}
 901     else
 902       _ -> get_obj_helper(object_id)
 903     end
 904   end
 905
 906   def get_embedded_obj_helper(object_id, _) do
 907     get_obj_helper(object_id)
 908   end
 909
 910   def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
 911     with false <- String.starts_with?(in_reply_to, "http"),
 912          {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
 913       Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
 914     else
 915       _e -> object
 916     end
 917   end
 918
 919   def set_reply_to_uri(obj), do: obj
 920
 921   @doc """
 922   Serialized Mastodon-compatible `replies` collection containing _self-replies_.
 923   Based on Mastodon's ActivityPub::NoteSerializer#replies.
 924   """
 925   def set_replies(obj_data) do
 926     replies_uris =
 927       with limit when limit > 0 <-
 928              Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
 929            %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
 930         object
 931         |> Object.self_replies()
 932         |> select([o], fragment("?->>'id'", o.data))
 933         |> limit(^limit)
 934         |> Repo.all()
 935       else
 936         _ -> []
 937       end
 938
 939     set_replies(obj_data, replies_uris)
 940   end
 941
 942   defp set_replies(obj, []) do
 943     obj
 944   end
 945
 946   defp set_replies(obj, replies_uris) do
 947     replies_collection = %{
 948       "type" => "Collection",
 949       "items" => replies_uris
 950     }
 951
 952     Map.merge(obj, %{"replies" => replies_collection})
 953   end
 954
 955   def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
 956     items
 957   end
 958
 959   def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
 960     items
 961   end
 962
 963   def replies(_), do: []
 964
 965   # Prepares the object of an outgoing create activity.
 966   def prepare_object(object) do
 967     object
 968     |> set_sensitive
 969     |> add_hashtags
 970     |> add_mention_tags
 971     |> add_emoji_tags
 972     |> add_attributed_to
 973     |> prepare_attachments
 974     |> set_conversation
 975     |> set_reply_to_uri
 976     |> set_replies
 977     |> strip_internal_fields
 978     |> strip_internal_tags
 979     |> set_type
 980   end
 981
 982   #  @doc
 983   #  """
 984   #  internal -> Mastodon
 985   #  """
 986
 987   def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
 988       when activity_type in ["Create", "Listen"] do
 989     object =
 990       object_id
 991       |> Object.normalize()
 992       |> Map.get(:data)
 993       |> prepare_object
 994
 995     data =
 996       data
 997       |> Map.put("object", object)
 998       |> Map.merge(Utils.make_json_ld_header())
 999       |> Map.delete("bcc")
1000
1001     {:ok, data}
1002   end
1003
1004   def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
1005     object =
1006       object_id
1007       |> Object.normalize()
1008
1009     data =
1010       if Visibility.is_private?(object) && object.data["actor"] == ap_id do
1011         data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
1012       else
1013         data |> maybe_fix_object_url
1014       end
1015
1016     data =
1017       data
1018       |> strip_internal_fields
1019       |> Map.merge(Utils.make_json_ld_header())
1020       |> Map.delete("bcc")
1021
1022     {:ok, data}
1023   end
1024
1025   # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
1026   # because of course it does.
1027   def prepare_outgoing(%{"type" => "Accept"} = data) do
1028     with follow_activity <- Activity.normalize(data["object"]) do
1029       object = %{
1030         "actor" => follow_activity.actor,
1031         "object" => follow_activity.data["object"],
1032         "id" => follow_activity.data["id"],
1033         "type" => "Follow"
1034       }
1035
1036       data =
1037         data
1038         |> Map.put("object", object)
1039         |> Map.merge(Utils.make_json_ld_header())
1040
1041       {:ok, data}
1042     end
1043   end
1044
1045   def prepare_outgoing(%{"type" => "Reject"} = data) do
1046     with follow_activity <- Activity.normalize(data["object"]) do
1047       object = %{
1048         "actor" => follow_activity.actor,
1049         "object" => follow_activity.data["object"],
1050         "id" => follow_activity.data["id"],
1051         "type" => "Follow"
1052       }
1053
1054       data =
1055         data
1056         |> Map.put("object", object)
1057         |> Map.merge(Utils.make_json_ld_header())
1058
1059       {:ok, data}
1060     end
1061   end
1062
1063   def prepare_outgoing(%{"type" => _type} = data) do
1064     data =
1065       data
1066       |> strip_internal_fields
1067       |> maybe_fix_object_url
1068       |> Map.merge(Utils.make_json_ld_header())
1069
1070     {:ok, data}
1071   end
1072
1073   def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
1074     with false <- String.starts_with?(object, "http"),
1075          {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
1076          %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
1077            relative_object do
1078       Map.put(data, "object", external_url)
1079     else
1080       {:fetch, e} ->
1081         Logger.error("Couldn't fetch #{object} #{inspect(e)}")
1082         data
1083
1084       _ ->
1085         data
1086     end
1087   end
1088
1089   def maybe_fix_object_url(data), do: data
1090
1091   def add_hashtags(object) do
1092     tags =
1093       (object["tag"] || [])
1094       |> Enum.map(fn
1095         # Expand internal representation tags into AS2 tags.
1096         tag when is_binary(tag) ->
1097           %{
1098             "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
1099             "name" => "##{tag}",
1100             "type" => "Hashtag"
1101           }
1102
1103         # Do not process tags which are already AS2 tag objects.
1104         tag when is_map(tag) ->
1105           tag
1106       end)
1107
1108     Map.put(object, "tag", tags)
1109   end
1110
1111   def add_mention_tags(object) do
1112     {enabled_receivers, disabled_receivers} = Utils.get_notified_from_object(object)
1113     potential_receivers = enabled_receivers ++ disabled_receivers
1114     mentions = Enum.map(potential_receivers, &build_mention_tag/1)
1115
1116     tags = object["tag"] || []
1117     Map.put(object, "tag", tags ++ mentions)
1118   end
1119
1120   defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1121     %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1122   end
1123
1124   def take_emoji_tags(%User{emoji: emoji}) do
1125     emoji
1126     |> Enum.flat_map(&Map.to_list/1)
1127     |> Enum.map(&build_emoji_tag/1)
1128   end
1129
1130   # TODO: we should probably send mtime instead of unix epoch time for updated
1131   def add_emoji_tags(%{"emoji" => emoji} = object) do
1132     tags = object["tag"] || []
1133
1134     out = Enum.map(emoji, &build_emoji_tag/1)
1135
1136     Map.put(object, "tag", tags ++ out)
1137   end
1138
1139   def add_emoji_tags(object), do: object
1140
1141   defp build_emoji_tag({name, url}) do
1142     %{
1143       "icon" => %{"url" => url, "type" => "Image"},
1144       "name" => ":" <> name <> ":",
1145       "type" => "Emoji",
1146       "updated" => "1970-01-01T00:00:00Z",
1147       "id" => url
1148     }
1149   end
1150
1151   def set_conversation(object) do
1152     Map.put(object, "conversation", object["context"])
1153   end
1154
1155   def set_sensitive(object) do
1156     tags = object["tag"] || []
1157     Map.put(object, "sensitive", "nsfw" in tags)
1158   end
1159
1160   def set_type(%{"type" => "Answer"} = object) do
1161     Map.put(object, "type", "Note")
1162   end
1163
1164   def set_type(object), do: object
1165
1166   def add_attributed_to(object) do
1167     attributed_to = object["attributedTo"] || object["actor"]
1168     Map.put(object, "attributedTo", attributed_to)
1169   end
1170
1171   def prepare_attachments(object) do
1172     attachments =
1173       (object["attachment"] || [])
1174       |> Enum.map(fn data ->
1175         [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1176         %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1177       end)
1178
1179     Map.put(object, "attachment", attachments)
1180   end
1181
1182   def strip_internal_fields(object) do
1183     object
1184     |> Map.drop(Pleroma.Constants.object_internal_fields())
1185   end
1186
1187   defp strip_internal_tags(%{"tag" => tags} = object) do
1188     tags = Enum.filter(tags, fn x -> is_map(x) end)
1189
1190     Map.put(object, "tag", tags)
1191   end
1192
1193   defp strip_internal_tags(object), do: object
1194
1195   def perform(:user_upgrade, user) do
1196     # we pass a fake user so that the followers collection is stripped away
1197     old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1198
1199     from(
1200       a in Activity,
1201       where: ^old_follower_address in a.recipients,
1202       update: [
1203         set: [
1204           recipients:
1205             fragment(
1206               "array_replace(?,?,?)",
1207               a.recipients,
1208               ^old_follower_address,
1209               ^user.follower_address
1210             )
1211         ]
1212       ]
1213     )
1214     |> Repo.update_all([])
1215   end
1216
1217   def upgrade_user_from_ap_id(ap_id) do
1218     with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1219          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1220          already_ap <- User.ap_enabled?(user),
1221          {:ok, user} <- upgrade_user(user, data) do
1222       if not already_ap do
1223         TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1224       end
1225
1226       {:ok, user}
1227     else
1228       %User{} = user -> {:ok, user}
1229       e -> e
1230     end
1231   end
1232
1233   defp upgrade_user(user, data) do
1234     user
1235     |> User.upgrade_changeset(data, true)
1236     |> User.update_and_set_cache()
1237   end
1238
1239   def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1240     Map.put(data, "url", url["href"])
1241   end
1242
1243   def maybe_fix_user_url(data), do: data
1244
1245   def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
1246 end