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