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