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