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 {_, {:ok, cast_data_sym}} <-
 570            {:casting_data,
 571             data |> LikeValidator.cast_data() |> Ecto.Changeset.apply_action(:insert)},
 572          {_, cast_data} <-
 573            {:stringify_keys, ObjectValidator.stringify_keys(cast_data_sym |> Map.from_struct())},
 574          :ok <- ObjectValidator.fetch_actor_and_object(cast_data),
 575          {_, {:ok, cast_data}} <- {:maybe_add_context, maybe_add_context_from_object(cast_data)},
 576          {_, {:ok, cast_data}} <-
 577            {:maybe_add_recipients, maybe_add_recipients_from_object(cast_data)},
 578          {_, {:ok, activity, _meta}} <-
 579            {:common_pipeline, Pipeline.common_pipeline(cast_data, local: false)} do
 580       {:ok, activity}
 581     else
 582       e -> {:error, e}
 583     end
 584   end
 585
 586   def handle_incoming(
 587         %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
 588         _options
 589       ) do
 590     with actor <- Containment.get_actor(data),
 591          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 592          {:ok, object} <- get_embedded_obj_helper(object_id, actor),
 593          public <- Visibility.is_public?(data),
 594          {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
 595       {:ok, activity}
 596     else
 597       _e -> :error
 598     end
 599   end
 600
 601   def handle_incoming(
 602         %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
 603           data,
 604         _options
 605       )
 606       when object_type in ["Person", "Application", "Service", "Organization"] do
 607     with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
 608       {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
 609
 610       banner = new_user_data[:info][:banner]
 611       locked = new_user_data[:info][:locked] || false
 612       attachment = get_in(new_user_data, [:info, :source_data, "attachment"]) || []
 613
 614       fields =
 615         attachment
 616         |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
 617         |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
 618
 619       update_data =
 620         new_user_data
 621         |> Map.take([:name, :bio, :avatar])
 622         |> Map.put(:info, %{banner: banner, locked: locked, fields: fields})
 623
 624       actor
 625       |> User.upgrade_changeset(update_data, true)
 626       |> User.update_and_set_cache()
 627
 628       ActivityPub.update(%{
 629         local: false,
 630         to: data["to"] || [],
 631         cc: data["cc"] || [],
 632         object: object,
 633         actor: actor_id,
 634         activity_id: data["id"]
 635       })
 636     else
 637       e ->
 638         Logger.error(e)
 639         :error
 640     end
 641   end
 642
 643   # TODO: We presently assume that any actor on the same origin domain as the object being
 644   # deleted has the rights to delete that object.  A better way to validate whether or not
 645   # the object should be deleted is to refetch the object URI, which should return either
 646   # an error or a tombstone.  This would allow us to verify that a deletion actually took
 647   # place.
 648   def handle_incoming(
 649         %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
 650         _options
 651       ) do
 652     object_id = Utils.get_ap_id(object_id)
 653
 654     with actor <- Containment.get_actor(data),
 655          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 656          {:ok, object} <- get_obj_helper(object_id),
 657          :ok <- Containment.contain_origin(actor.ap_id, object.data),
 658          {:ok, activity} <-
 659            ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
 660       {:ok, activity}
 661     else
 662       nil ->
 663         case User.get_cached_by_ap_id(object_id) do
 664           %User{ap_id: ^actor} = user ->
 665             User.delete(user)
 666
 667           nil ->
 668             :error
 669         end
 670
 671       _e ->
 672         :error
 673     end
 674   end
 675
 676   def handle_incoming(
 677         %{
 678           "type" => "Undo",
 679           "object" => %{"type" => "Announce", "object" => object_id},
 680           "actor" => _actor,
 681           "id" => id
 682         } = data,
 683         _options
 684       ) do
 685     with actor <- Containment.get_actor(data),
 686          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 687          {:ok, object} <- get_obj_helper(object_id),
 688          {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
 689       {:ok, activity}
 690     else
 691       _e -> :error
 692     end
 693   end
 694
 695   def handle_incoming(
 696         %{
 697           "type" => "Undo",
 698           "object" => %{"type" => "Follow", "object" => followed},
 699           "actor" => follower,
 700           "id" => id
 701         } = _data,
 702         _options
 703       ) do
 704     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 705          {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
 706          {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
 707       User.unfollow(follower, followed)
 708       {:ok, activity}
 709     else
 710       _e -> :error
 711     end
 712   end
 713
 714   def handle_incoming(
 715         %{
 716           "type" => "Undo",
 717           "object" => %{"type" => "Block", "object" => blocked},
 718           "actor" => blocker,
 719           "id" => id
 720         } = _data,
 721         _options
 722       ) do
 723     with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
 724          {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
 725          {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
 726       User.unblock(blocker, blocked)
 727       {:ok, activity}
 728     else
 729       _e -> :error
 730     end
 731   end
 732
 733   def handle_incoming(
 734         %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
 735         _options
 736       ) do
 737     with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
 738          {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
 739          {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
 740       User.unfollow(blocker, blocked)
 741       User.block(blocker, blocked)
 742       {:ok, activity}
 743     else
 744       _e -> :error
 745     end
 746   end
 747
 748   def handle_incoming(
 749         %{
 750           "type" => "Undo",
 751           "object" => %{"type" => "Like", "object" => object_id},
 752           "actor" => _actor,
 753           "id" => id
 754         } = data,
 755         _options
 756       ) do
 757     with actor <- Containment.get_actor(data),
 758          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 759          {:ok, object} <- get_obj_helper(object_id),
 760          {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
 761       {:ok, activity}
 762     else
 763       _e -> :error
 764     end
 765   end
 766
 767   # For Undos that don't have the complete object attached, try to find it in our database.
 768   def handle_incoming(
 769         %{
 770           "type" => "Undo",
 771           "object" => object
 772         } = activity,
 773         options
 774       )
 775       when is_binary(object) do
 776     with %Activity{data: data} <- Activity.get_by_ap_id(object) do
 777       activity
 778       |> Map.put("object", data)
 779       |> handle_incoming(options)
 780     else
 781       _e -> :error
 782     end
 783   end
 784
 785   def handle_incoming(_, _), do: :error
 786
 787   @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
 788   def get_obj_helper(id, options \\ []) do
 789     case Object.normalize(id, true, options) do
 790       %Object{} = object -> {:ok, object}
 791       _ -> nil
 792     end
 793   end
 794
 795   @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
 796   def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
 797         ap_id: ap_id
 798       })
 799       when attributed_to == ap_id do
 800     with {:ok, activity} <-
 801            handle_incoming(%{
 802              "type" => "Create",
 803              "to" => data["to"],
 804              "cc" => data["cc"],
 805              "actor" => attributed_to,
 806              "object" => data
 807            }) do
 808       {:ok, Object.normalize(activity)}
 809     else
 810       _ -> get_obj_helper(object_id)
 811     end
 812   end
 813
 814   def get_embedded_obj_helper(object_id, _) do
 815     get_obj_helper(object_id)
 816   end
 817
 818   def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
 819     with false <- String.starts_with?(in_reply_to, "http"),
 820          {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
 821       Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
 822     else
 823       _e -> object
 824     end
 825   end
 826
 827   def set_reply_to_uri(obj), do: obj
 828
 829   # Prepares the object of an outgoing create activity.
 830   def prepare_object(object) do
 831     object
 832     |> set_sensitive
 833     |> add_hashtags
 834     |> add_mention_tags
 835     |> add_emoji_tags
 836     |> add_attributed_to
 837     |> prepare_attachments
 838     |> set_conversation
 839     |> set_reply_to_uri
 840     |> strip_internal_fields
 841     |> strip_internal_tags
 842     |> set_type
 843   end
 844
 845   #  @doc
 846   #  """
 847   #  internal -> Mastodon
 848   #  """
 849
 850   def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
 851       when activity_type in ["Create", "Listen"] do
 852     object =
 853       object_id
 854       |> Object.normalize()
 855       |> Map.get(:data)
 856       |> prepare_object
 857
 858     data =
 859       data
 860       |> Map.put("object", object)
 861       |> Map.merge(Utils.make_json_ld_header())
 862       |> Map.delete("bcc")
 863
 864     {:ok, data}
 865   end
 866
 867   def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
 868     object =
 869       object_id
 870       |> Object.normalize()
 871
 872     data =
 873       if Visibility.is_private?(object) && object.data["actor"] == ap_id do
 874         data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
 875       else
 876         data |> maybe_fix_object_url
 877       end
 878
 879     data =
 880       data
 881       |> strip_internal_fields
 882       |> Map.merge(Utils.make_json_ld_header())
 883       |> Map.delete("bcc")
 884
 885     {:ok, data}
 886   end
 887
 888   # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
 889   # because of course it does.
 890   def prepare_outgoing(%{"type" => "Accept"} = data) do
 891     with follow_activity <- Activity.normalize(data["object"]) do
 892       object = %{
 893         "actor" => follow_activity.actor,
 894         "object" => follow_activity.data["object"],
 895         "id" => follow_activity.data["id"],
 896         "type" => "Follow"
 897       }
 898
 899       data =
 900         data
 901         |> Map.put("object", object)
 902         |> Map.merge(Utils.make_json_ld_header())
 903
 904       {:ok, data}
 905     end
 906   end
 907
 908   def prepare_outgoing(%{"type" => "Reject"} = data) do
 909     with follow_activity <- Activity.normalize(data["object"]) do
 910       object = %{
 911         "actor" => follow_activity.actor,
 912         "object" => follow_activity.data["object"],
 913         "id" => follow_activity.data["id"],
 914         "type" => "Follow"
 915       }
 916
 917       data =
 918         data
 919         |> Map.put("object", object)
 920         |> Map.merge(Utils.make_json_ld_header())
 921
 922       {:ok, data}
 923     end
 924   end
 925
 926   def prepare_outgoing(%{"type" => _type} = data) do
 927     data =
 928       data
 929       |> strip_internal_fields
 930       |> maybe_fix_object_url
 931       |> Map.merge(Utils.make_json_ld_header())
 932
 933     {:ok, data}
 934   end
 935
 936   def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
 937     with false <- String.starts_with?(object, "http"),
 938          {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
 939          %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
 940            relative_object do
 941       Map.put(data, "object", external_url)
 942     else
 943       {:fetch, e} ->
 944         Logger.error("Couldn't fetch #{object} #{inspect(e)}")
 945         data
 946
 947       _ ->
 948         data
 949     end
 950   end
 951
 952   def maybe_fix_object_url(data), do: data
 953
 954   def add_hashtags(object) do
 955     tags =
 956       (object["tag"] || [])
 957       |> Enum.map(fn
 958         # Expand internal representation tags into AS2 tags.
 959         tag when is_binary(tag) ->
 960           %{
 961             "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
 962             "name" => "##{tag}",
 963             "type" => "Hashtag"
 964           }
 965
 966         # Do not process tags which are already AS2 tag objects.
 967         tag when is_map(tag) ->
 968           tag
 969       end)
 970
 971     Map.put(object, "tag", tags)
 972   end
 973
 974   def add_mention_tags(object) do
 975     mentions =
 976       object
 977       |> Utils.get_notified_from_object()
 978       |> Enum.map(&build_mention_tag/1)
 979
 980     tags = object["tag"] || []
 981
 982     Map.put(object, "tag", tags ++ mentions)
 983   end
 984
 985   defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
 986     %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
 987   end
 988
 989   def take_emoji_tags(%User{info: %{emoji: emoji} = _user_info} = _user) do
 990     emoji
 991     |> Enum.flat_map(&Map.to_list/1)
 992     |> Enum.map(&build_emoji_tag/1)
 993   end
 994
 995   # TODO: we should probably send mtime instead of unix epoch time for updated
 996   def add_emoji_tags(%{"emoji" => emoji} = object) do
 997     tags = object["tag"] || []
 998
 999     out = Enum.map(emoji, &build_emoji_tag/1)
1000
1001     Map.put(object, "tag", tags ++ out)
1002   end
1003
1004   def add_emoji_tags(object), do: object
1005
1006   defp build_emoji_tag({name, url}) do
1007     %{
1008       "icon" => %{"url" => url, "type" => "Image"},
1009       "name" => ":" <> name <> ":",
1010       "type" => "Emoji",
1011       "updated" => "1970-01-01T00:00:00Z",
1012       "id" => url
1013     }
1014   end
1015
1016   def set_conversation(object) do
1017     Map.put(object, "conversation", object["context"])
1018   end
1019
1020   def set_sensitive(object) do
1021     tags = object["tag"] || []
1022     Map.put(object, "sensitive", "nsfw" in tags)
1023   end
1024
1025   def set_type(%{"type" => "Answer"} = object) do
1026     Map.put(object, "type", "Note")
1027   end
1028
1029   def set_type(object), do: object
1030
1031   def add_attributed_to(object) do
1032     attributed_to = object["attributedTo"] || object["actor"]
1033     Map.put(object, "attributedTo", attributed_to)
1034   end
1035
1036   def prepare_attachments(object) do
1037     attachments =
1038       (object["attachment"] || [])
1039       |> Enum.map(fn data ->
1040         [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1041         %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1042       end)
1043
1044     Map.put(object, "attachment", attachments)
1045   end
1046
1047   defp strip_internal_fields(object) do
1048     object
1049     |> Map.drop(Pleroma.Constants.object_internal_fields())
1050   end
1051
1052   defp strip_internal_tags(%{"tag" => tags} = object) do
1053     tags = Enum.filter(tags, fn x -> is_map(x) end)
1054
1055     Map.put(object, "tag", tags)
1056   end
1057
1058   defp strip_internal_tags(object), do: object
1059
1060   def perform(:user_upgrade, user) do
1061     # we pass a fake user so that the followers collection is stripped away
1062     old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1063
1064     q =
1065       from(
1066         u in User,
1067         where: ^old_follower_address in u.following,
1068         update: [
1069           set: [
1070             following:
1071               fragment(
1072                 "array_replace(?,?,?)",
1073                 u.following,
1074                 ^old_follower_address,
1075                 ^user.follower_address
1076               )
1077           ]
1078         ]
1079       )
1080
1081     Repo.update_all(q, [])
1082
1083     maybe_retire_websub(user.ap_id)
1084
1085     q =
1086       from(
1087         a in Activity,
1088         where: ^old_follower_address in a.recipients,
1089         update: [
1090           set: [
1091             recipients:
1092               fragment(
1093                 "array_replace(?,?,?)",
1094                 a.recipients,
1095                 ^old_follower_address,
1096                 ^user.follower_address
1097               )
1098           ]
1099         ]
1100       )
1101
1102     Repo.update_all(q, [])
1103   end
1104
1105   def upgrade_user_from_ap_id(ap_id) do
1106     with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1107          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1108          already_ap <- User.ap_enabled?(user),
1109          {:ok, user} <- upgrade_user(user, data) do
1110       if not already_ap do
1111         TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1112       end
1113
1114       {:ok, user}
1115     else
1116       %User{} = user -> {:ok, user}
1117       e -> e
1118     end
1119   end
1120
1121   defp upgrade_user(user, data) do
1122     user
1123     |> User.upgrade_changeset(data, true)
1124     |> User.update_and_set_cache()
1125   end
1126
1127   def maybe_retire_websub(ap_id) do
1128     # some sanity checks
1129     if is_binary(ap_id) && String.length(ap_id) > 8 do
1130       q =
1131         from(
1132           ws in Pleroma.Web.Websub.WebsubClientSubscription,
1133           where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
1134         )
1135
1136       Repo.delete_all(q)
1137     end
1138   end
1139
1140   def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1141     Map.put(data, "url", url["href"])
1142   end
1143
1144   def maybe_fix_user_url(data), do: data
1145
1146   def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
1147
1148   defp maybe_add_context_from_object(%{"context" => context} = data) when is_binary(context),
1149     do: {:ok, data}
1150
1151   defp maybe_add_context_from_object(%{"object" => object} = data) when is_binary(object) do
1152     if object = Object.normalize(object) do
1153       data =
1154         data
1155         |> Map.put("context", object.data["context"])
1156
1157       {:ok, data}
1158     else
1159       {:error, "No context on referenced object"}
1160     end
1161   end
1162
1163   defp maybe_add_context_from_object(_) do
1164     {:error, "No referenced object"}
1165   end
1166
1167   defp maybe_add_recipients_from_object(%{"object" => object} = data) do
1168     to = data["to"] || []
1169     cc = data["cc"] || []
1170
1171     if to == [] && cc == [] do
1172       if object = Object.normalize(object) do
1173         data =
1174           data
1175           |> Map.put("to", [object.data["actor"]])
1176           |> Map.put("cc", cc)
1177
1178         {:ok, data}
1179       else
1180         {:error, "No actor on referenced object"}
1181       end
1182     else
1183       {:ok, data}
1184     end
1185   end
1186
1187   defp maybe_add_recipients_from_object(_) do
1188     {:error, "No referenced object"}
1189   end
1190 end