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