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