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}} = data,
 638         _options
 639       )
 640       when objtype in ["Question", "Answer", "ChatMessage"] do
 641     with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
 642          {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
 643       {:ok, activity}
 644     end
 645   end
 646
 647   def handle_incoming(%{"type" => type} = data, _options)
 648       when type in ~w{Like EmojiReact Announce} do
 649     with :ok <- ObjectValidator.fetch_actor_and_object(data),
 650          {:ok, activity, _meta} <-
 651            Pipeline.common_pipeline(data, local: false) do
 652       {:ok, activity}
 653     else
 654       e -> {:error, e}
 655     end
 656   end
 657
 658   def handle_incoming(
 659         %{"type" => type} = data,
 660         _options
 661       )
 662       when type in ~w{Update Block Follow} do
 663     with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
 664          {:ok, activity, _} <-
 665            Pipeline.common_pipeline(data, local: false) do
 666       {:ok, activity}
 667     end
 668   end
 669
 670   def handle_incoming(
 671         %{"type" => "Delete"} = data,
 672         _options
 673       ) do
 674     with {:ok, activity, _} <-
 675            Pipeline.common_pipeline(data, local: false) do
 676       {:ok, activity}
 677     else
 678       {:error, {:validate_object, _}} = e ->
 679         # Check if we have a create activity for this
 680         with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
 681              %Activity{data: %{"actor" => actor}} <-
 682                Activity.create_by_object_ap_id(object_id) |> Repo.one(),
 683              # We have one, insert a tombstone and retry
 684              {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
 685              {:ok, _tombstone} <- Object.create(tombstone_data) do
 686           handle_incoming(data)
 687         else
 688           _ -> e
 689         end
 690     end
 691   end
 692
 693   def handle_incoming(
 694         %{
 695           "type" => "Undo",
 696           "object" => %{"type" => "Follow", "object" => followed},
 697           "actor" => follower,
 698           "id" => id
 699         } = _data,
 700         _options
 701       ) do
 702     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 703          {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
 704          {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
 705       User.unfollow(follower, followed)
 706       {:ok, activity}
 707     else
 708       _e -> :error
 709     end
 710   end
 711
 712   def handle_incoming(
 713         %{
 714           "type" => "Undo",
 715           "object" => %{"type" => type}
 716         } = data,
 717         _options
 718       )
 719       when type in ["Like", "EmojiReact", "Announce", "Block"] do
 720     with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
 721       {:ok, activity}
 722     end
 723   end
 724
 725   # For Undos that don't have the complete object attached, try to find it in our database.
 726   def handle_incoming(
 727         %{
 728           "type" => "Undo",
 729           "object" => object
 730         } = activity,
 731         options
 732       )
 733       when is_binary(object) do
 734     with %Activity{data: data} <- Activity.get_by_ap_id(object) do
 735       activity
 736       |> Map.put("object", data)
 737       |> handle_incoming(options)
 738     else
 739       _e -> :error
 740     end
 741   end
 742
 743   def handle_incoming(
 744         %{
 745           "type" => "Move",
 746           "actor" => origin_actor,
 747           "object" => origin_actor,
 748           "target" => target_actor
 749         },
 750         _options
 751       ) do
 752     with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
 753          {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
 754          true <- origin_actor in target_user.also_known_as do
 755       ActivityPub.move(origin_user, target_user, false)
 756     else
 757       _e -> :error
 758     end
 759   end
 760
 761   def handle_incoming(_, _), do: :error
 762
 763   @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
 764   def get_obj_helper(id, options \\ []) do
 765     case Object.normalize(id, true, options) do
 766       %Object{} = object -> {:ok, object}
 767       _ -> nil
 768     end
 769   end
 770
 771   @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
 772   def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
 773         ap_id: ap_id
 774       })
 775       when attributed_to == ap_id do
 776     with {:ok, activity} <-
 777            handle_incoming(%{
 778              "type" => "Create",
 779              "to" => data["to"],
 780              "cc" => data["cc"],
 781              "actor" => attributed_to,
 782              "object" => data
 783            }) do
 784       {:ok, Object.normalize(activity)}
 785     else
 786       _ -> get_obj_helper(object_id)
 787     end
 788   end
 789
 790   def get_embedded_obj_helper(object_id, _) do
 791     get_obj_helper(object_id)
 792   end
 793
 794   def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
 795     with false <- String.starts_with?(in_reply_to, "http"),
 796          {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
 797       Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
 798     else
 799       _e -> object
 800     end
 801   end
 802
 803   def set_reply_to_uri(obj), do: obj
 804
 805   @doc """
 806   Serialized Mastodon-compatible `replies` collection containing _self-replies_.
 807   Based on Mastodon's ActivityPub::NoteSerializer#replies.
 808   """
 809   def set_replies(obj_data) do
 810     replies_uris =
 811       with limit when limit > 0 <-
 812              Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
 813            %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
 814         object
 815         |> Object.self_replies()
 816         |> select([o], fragment("?->>'id'", o.data))
 817         |> limit(^limit)
 818         |> Repo.all()
 819       else
 820         _ -> []
 821       end
 822
 823     set_replies(obj_data, replies_uris)
 824   end
 825
 826   defp set_replies(obj, []) do
 827     obj
 828   end
 829
 830   defp set_replies(obj, replies_uris) do
 831     replies_collection = %{
 832       "type" => "Collection",
 833       "items" => replies_uris
 834     }
 835
 836     Map.merge(obj, %{"replies" => replies_collection})
 837   end
 838
 839   def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
 840     items
 841   end
 842
 843   def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
 844     items
 845   end
 846
 847   def replies(_), do: []
 848
 849   # Prepares the object of an outgoing create activity.
 850   def prepare_object(object) do
 851     object
 852     |> set_sensitive
 853     |> add_hashtags
 854     |> add_mention_tags
 855     |> add_emoji_tags
 856     |> add_attributed_to
 857     |> prepare_attachments
 858     |> set_conversation
 859     |> set_reply_to_uri
 860     |> set_replies
 861     |> strip_internal_fields
 862     |> strip_internal_tags
 863     |> set_type
 864   end
 865
 866   #  @doc
 867   #  """
 868   #  internal -> Mastodon
 869   #  """
 870
 871   def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
 872       when activity_type in ["Create", "Listen"] do
 873     object =
 874       object_id
 875       |> Object.normalize()
 876       |> Map.get(:data)
 877       |> prepare_object
 878
 879     data =
 880       data
 881       |> Map.put("object", object)
 882       |> Map.merge(Utils.make_json_ld_header())
 883       |> Map.delete("bcc")
 884
 885     {:ok, data}
 886   end
 887
 888   def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
 889     object =
 890       object_id
 891       |> Object.normalize()
 892
 893     data =
 894       if Visibility.is_private?(object) && object.data["actor"] == ap_id do
 895         data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
 896       else
 897         data |> maybe_fix_object_url
 898       end
 899
 900     data =
 901       data
 902       |> strip_internal_fields
 903       |> Map.merge(Utils.make_json_ld_header())
 904       |> Map.delete("bcc")
 905
 906     {:ok, data}
 907   end
 908
 909   # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
 910   # because of course it does.
 911   def prepare_outgoing(%{"type" => "Accept"} = data) do
 912     with follow_activity <- Activity.normalize(data["object"]) do
 913       object = %{
 914         "actor" => follow_activity.actor,
 915         "object" => follow_activity.data["object"],
 916         "id" => follow_activity.data["id"],
 917         "type" => "Follow"
 918       }
 919
 920       data =
 921         data
 922         |> Map.put("object", object)
 923         |> Map.merge(Utils.make_json_ld_header())
 924
 925       {:ok, data}
 926     end
 927   end
 928
 929   def prepare_outgoing(%{"type" => "Reject"} = data) do
 930     with follow_activity <- Activity.normalize(data["object"]) do
 931       object = %{
 932         "actor" => follow_activity.actor,
 933         "object" => follow_activity.data["object"],
 934         "id" => follow_activity.data["id"],
 935         "type" => "Follow"
 936       }
 937
 938       data =
 939         data
 940         |> Map.put("object", object)
 941         |> Map.merge(Utils.make_json_ld_header())
 942
 943       {:ok, data}
 944     end
 945   end
 946
 947   def prepare_outgoing(%{"type" => _type} = data) do
 948     data =
 949       data
 950       |> strip_internal_fields
 951       |> maybe_fix_object_url
 952       |> Map.merge(Utils.make_json_ld_header())
 953
 954     {:ok, data}
 955   end
 956
 957   def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
 958     with false <- String.starts_with?(object, "http"),
 959          {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
 960          %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
 961            relative_object do
 962       Map.put(data, "object", external_url)
 963     else
 964       {:fetch, e} ->
 965         Logger.error("Couldn't fetch #{object} #{inspect(e)}")
 966         data
 967
 968       _ ->
 969         data
 970     end
 971   end
 972
 973   def maybe_fix_object_url(data), do: data
 974
 975   def add_hashtags(object) do
 976     tags =
 977       (object["tag"] || [])
 978       |> Enum.map(fn
 979         # Expand internal representation tags into AS2 tags.
 980         tag when is_binary(tag) ->
 981           %{
 982             "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
 983             "name" => "##{tag}",
 984             "type" => "Hashtag"
 985           }
 986
 987         # Do not process tags which are already AS2 tag objects.
 988         tag when is_map(tag) ->
 989           tag
 990       end)
 991
 992     Map.put(object, "tag", tags)
 993   end
 994
 995   # TODO These should be added on our side on insertion, it doesn't make much
 996   # sense to regenerate these all the time
 997   def add_mention_tags(object) do
 998     to = object["to"] || []
 999     cc = object["cc"] || []
1000     mentioned = User.get_users_from_set(to ++ cc, local_only: false)
1001
1002     mentions = Enum.map(mentioned, &build_mention_tag/1)
1003
1004     tags = object["tag"] || []
1005     Map.put(object, "tag", tags ++ mentions)
1006   end
1007
1008   defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1009     %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1010   end
1011
1012   def take_emoji_tags(%User{emoji: emoji}) do
1013     emoji
1014     |> Map.to_list()
1015     |> Enum.map(&build_emoji_tag/1)
1016   end
1017
1018   # TODO: we should probably send mtime instead of unix epoch time for updated
1019   def add_emoji_tags(%{"emoji" => emoji} = object) do
1020     tags = object["tag"] || []
1021
1022     out = Enum.map(emoji, &build_emoji_tag/1)
1023
1024     Map.put(object, "tag", tags ++ out)
1025   end
1026
1027   def add_emoji_tags(object), do: object
1028
1029   defp build_emoji_tag({name, url}) do
1030     %{
1031       "icon" => %{"url" => url, "type" => "Image"},
1032       "name" => ":" <> name <> ":",
1033       "type" => "Emoji",
1034       "updated" => "1970-01-01T00:00:00Z",
1035       "id" => url
1036     }
1037   end
1038
1039   def set_conversation(object) do
1040     Map.put(object, "conversation", object["context"])
1041   end
1042
1043   def set_sensitive(%{"sensitive" => true} = object) do
1044     object
1045   end
1046
1047   def set_sensitive(object) do
1048     tags = object["tag"] || []
1049     Map.put(object, "sensitive", "nsfw" in tags)
1050   end
1051
1052   def set_type(%{"type" => "Answer"} = object) do
1053     Map.put(object, "type", "Note")
1054   end
1055
1056   def set_type(object), do: object
1057
1058   def add_attributed_to(object) do
1059     attributed_to = object["attributedTo"] || object["actor"]
1060     Map.put(object, "attributedTo", attributed_to)
1061   end
1062
1063   # TODO: Revisit this
1064   def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object
1065
1066   def prepare_attachments(object) do
1067     attachments =
1068       object
1069       |> Map.get("attachment", [])
1070       |> Enum.map(fn data ->
1071         [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1072
1073         %{
1074           "url" => href,
1075           "mediaType" => media_type,
1076           "name" => data["name"],
1077           "type" => "Document"
1078         }
1079       end)
1080
1081     Map.put(object, "attachment", attachments)
1082   end
1083
1084   def strip_internal_fields(object) do
1085     Map.drop(object, Pleroma.Constants.object_internal_fields())
1086   end
1087
1088   defp strip_internal_tags(%{"tag" => tags} = object) do
1089     tags = Enum.filter(tags, fn x -> is_map(x) end)
1090
1091     Map.put(object, "tag", tags)
1092   end
1093
1094   defp strip_internal_tags(object), do: object
1095
1096   def perform(:user_upgrade, user) do
1097     # we pass a fake user so that the followers collection is stripped away
1098     old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1099
1100     from(
1101       a in Activity,
1102       where: ^old_follower_address in a.recipients,
1103       update: [
1104         set: [
1105           recipients:
1106             fragment(
1107               "array_replace(?,?,?)",
1108               a.recipients,
1109               ^old_follower_address,
1110               ^user.follower_address
1111             )
1112         ]
1113       ]
1114     )
1115     |> Repo.update_all([])
1116   end
1117
1118   def upgrade_user_from_ap_id(ap_id) do
1119     with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1120          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1121          {:ok, user} <- update_user(user, data) do
1122       TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1123       {:ok, user}
1124     else
1125       %User{} = user -> {:ok, user}
1126       e -> e
1127     end
1128   end
1129
1130   defp update_user(user, data) do
1131     user
1132     |> User.remote_user_changeset(data)
1133     |> User.update_and_set_cache()
1134   end
1135
1136   def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1137     Map.put(data, "url", url["href"])
1138   end
1139
1140   def maybe_fix_user_url(data), do: data
1141
1142   def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
1143 end