git.squeep.com Git - akkoma/blob - lib/pleroma/web/activity_pub/transmogrifier.ex

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