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

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