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

   1 defmodule Pleroma.Web.ActivityPub.Transmogrifier do
   2   @moduledoc """
   3   A module to handle coding from internal to wire ActivityPub and back.
   4   """
   5   alias Pleroma.User
   6   alias Pleroma.Object
   7   alias Pleroma.Activity
   8   alias Pleroma.Repo
   9   alias Pleroma.Web.ActivityPub.ActivityPub
  10   alias Pleroma.Web.ActivityPub.Utils
  11
  12   import Ecto.Query
  13
  14   require Logger
  15
  16   def get_actor(%{"actor" => actor}) when is_binary(actor) do
  17     actor
  18   end
  19
  20   def get_actor(%{"actor" => actor}) when is_list(actor) do
  21     if is_binary(Enum.at(actor, 0)) do
  22       Enum.at(actor, 0)
  23     else
  24       Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
  25       |> Map.get("id")
  26     end
  27   end
  28
  29   def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
  30     id
  31   end
  32
  33   def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
  34     get_actor(%{"actor" => actor})
  35   end
  36
  37   @doc """
  38   Checks that an imported AP object's actor matches the domain it came from.
  39   """
  40   def contain_origin(id, %{"actor" => nil}), do: :error
  41
  42   def contain_origin(id, %{"actor" => actor} = params) do
  43     id_uri = URI.parse(id)
  44     actor_uri = URI.parse(get_actor(params))
  45
  46     if id_uri.host == actor_uri.host do
  47       :ok
  48     else
  49       :error
  50     end
  51   end
  52
  53   @doc """
  54   Modifies an incoming AP object (mastodon format) to our internal format.
  55   """
  56   def fix_object(object) do
  57     object
  58     |> fix_actor
  59     |> fix_attachments
  60     |> fix_context
  61     |> fix_in_reply_to
  62     |> fix_emoji
  63     |> fix_tag
  64     |> fix_content_map
  65     |> fix_likes
  66     |> fix_addressing
  67   end
  68
  69   def fix_addressing_list(map, field) do
  70     if is_binary(map[field]) do
  71       map
  72       |> Map.put(field, [map[field]])
  73     else
  74       map
  75     end
  76   end
  77
  78   def fix_addressing(map) do
  79     map
  80     |> fix_addressing_list("to")
  81     |> fix_addressing_list("cc")
  82     |> fix_addressing_list("bto")
  83     |> fix_addressing_list("bcc")
  84   end
  85
  86   def fix_actor(%{"attributedTo" => actor} = object) do
  87     object
  88     |> Map.put("actor", get_actor(%{"actor" => actor}))
  89   end
  90
  91   def fix_likes(%{"likes" => likes} = object)
  92       when is_bitstring(likes) do
  93     # Check for standardisation
  94     # This is what Peertube does
  95     # curl -H 'Accept: application/activity+json' $likes | jq .totalItems
  96     object
  97     |> Map.put("likes", [])
  98     |> Map.put("like_count", 0)
  99   end
 100
 101   def fix_likes(object) do
 102     object
 103   end
 104
 105   def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object)
 106       when not is_nil(in_reply_to) do
 107     in_reply_to_id =
 108       cond do
 109         is_bitstring(in_reply_to) ->
 110           in_reply_to
 111
 112         is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
 113           in_reply_to["id"]
 114
 115         is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
 116           Enum.at(in_reply_to, 0)
 117
 118         # Maybe I should output an error too?
 119         true ->
 120           ""
 121       end
 122
 123     case fetch_obj_helper(in_reply_to_id) do
 124       {:ok, replied_object} ->
 125         with %Activity{} = activity <-
 126                Activity.get_create_activity_by_object_ap_id(replied_object.data["id"]) do
 127           object
 128           |> Map.put("inReplyTo", replied_object.data["id"])
 129           |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
 130           |> Map.put("inReplyToStatusId", activity.id)
 131           |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
 132           |> Map.put("context", replied_object.data["context"] || object["conversation"])
 133         else
 134           e ->
 135             Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
 136             object
 137         end
 138
 139       e ->
 140         Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
 141         object
 142     end
 143   end
 144
 145   def fix_in_reply_to(object), do: object
 146
 147   def fix_context(object) do
 148     context = object["context"] || object["conversation"] || Utils.generate_context_id()
 149
 150     object
 151     |> Map.put("context", context)
 152     |> Map.put("conversation", context)
 153   end
 154
 155   def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
 156     attachments =
 157       attachment
 158       |> Enum.map(fn data ->
 159         url = [%{"type" => "Link", "mediaType" => data["mediaType"], "href" => data["url"]}]
 160         Map.put(data, "url", url)
 161       end)
 162
 163     object
 164     |> Map.put("attachment", attachments)
 165   end
 166
 167   def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
 168     Map.put(object, "attachment", [attachment])
 169     |> fix_attachments()
 170   end
 171
 172   def fix_attachments(object), do: object
 173
 174   def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
 175     emoji = tags |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
 176
 177     emoji =
 178       emoji
 179       |> Enum.reduce(%{}, fn data, mapping ->
 180         name = String.trim(data["name"], ":")
 181
 182         mapping |> Map.put(name, data["icon"]["url"])
 183       end)
 184
 185     # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
 186     emoji = Map.merge(object["emoji"] || %{}, emoji)
 187
 188     object
 189     |> Map.put("emoji", emoji)
 190   end
 191
 192   def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
 193     name = String.trim(tag["name"], ":")
 194     emoji = %{name => tag["icon"]["url"]}
 195
 196     object
 197     |> Map.put("emoji", emoji)
 198   end
 199
 200   def fix_emoji(object), do: object
 201
 202   def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
 203     tags =
 204       tag
 205       |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
 206       |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
 207
 208     combined = tag ++ tags
 209
 210     object
 211     |> Map.put("tag", combined)
 212   end
 213
 214   def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
 215     combined = [tag, String.slice(hashtag, 1..-1)]
 216
 217     object
 218     |> Map.put("tag", combined)
 219   end
 220
 221   def fix_tag(object), do: object
 222
 223   # content map usually only has one language so this will do for now.
 224   def fix_content_map(%{"contentMap" => content_map} = object) do
 225     content_groups = Map.to_list(content_map)
 226     {_, content} = Enum.at(content_groups, 0)
 227
 228     object
 229     |> Map.put("content", content)
 230   end
 231
 232   def fix_content_map(object), do: object
 233
 234   # disallow objects with bogus IDs
 235   def handle_incoming(%{"id" => nil}), do: :error
 236   def handle_incoming(%{"id" => ""}), do: :error
 237   # length of https:// = 8, should validate better, but good enough for now.
 238   def handle_incoming(%{"id" => id}) when not (is_binary(id) and length(id) > 8), do: :error
 239
 240   # TODO: validate those with a Ecto scheme
 241   # - tags
 242   # - emoji
 243   def handle_incoming(%{"type" => "Create", "object" => %{"type" => objtype} = object} = data)
 244       when objtype in ["Article", "Note", "Video"] do
 245     actor = get_actor(data)
 246
 247     data =
 248       Map.put(data, "actor", actor)
 249       |> fix_addressing
 250
 251     with nil <- Activity.get_create_activity_by_object_ap_id(object["id"]),
 252          %User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
 253       object = fix_object(data["object"])
 254
 255       params = %{
 256         to: data["to"],
 257         object: object,
 258         actor: user,
 259         context: object["conversation"],
 260         local: false,
 261         published: data["published"],
 262         additional:
 263           Map.take(data, [
 264             "cc",
 265             "id"
 266           ])
 267       }
 268
 269       ActivityPub.create(params)
 270     else
 271       %Activity{} = activity -> {:ok, activity}
 272       _e -> :error
 273     end
 274   end
 275
 276   def handle_incoming(
 277         %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
 278       ) do
 279     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 280          %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
 281          {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
 282       if not User.locked?(followed) do
 283         ActivityPub.accept(%{
 284           to: [follower.ap_id],
 285           actor: followed.ap_id,
 286           object: data,
 287           local: true
 288         })
 289
 290         User.follow(follower, followed)
 291       end
 292
 293       {:ok, activity}
 294     else
 295       _e -> :error
 296     end
 297   end
 298
 299   defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
 300     with true <- id =~ "follows",
 301          %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
 302          %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
 303       {:ok, activity}
 304     else
 305       _ -> {:error, nil}
 306     end
 307   end
 308
 309   defp mastodon_follow_hack(_), do: {:error, nil}
 310
 311   defp get_follow_activity(follow_object, followed) do
 312     with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
 313          {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
 314       {:ok, activity}
 315     else
 316       # Can't find the activity. This might a Mastodon 2.3 "Accept"
 317       {:activity, nil} ->
 318         mastodon_follow_hack(follow_object, followed)
 319
 320       _ ->
 321         {:error, nil}
 322     end
 323   end
 324
 325   def handle_incoming(
 326         %{"type" => "Accept", "object" => follow_object, "actor" => actor, "id" => id} = data
 327       ) do
 328     with actor <- get_actor(data),
 329          %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
 330          {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
 331          {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
 332          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
 333          {:ok, activity} <-
 334            ActivityPub.accept(%{
 335              to: follow_activity.data["to"],
 336              type: "Accept",
 337              actor: followed.ap_id,
 338              object: follow_activity.data["id"],
 339              local: false
 340            }) do
 341       if not User.following?(follower, followed) do
 342         {:ok, follower} = User.follow(follower, followed)
 343       end
 344
 345       {:ok, activity}
 346     else
 347       _e -> :error
 348     end
 349   end
 350
 351   def handle_incoming(
 352         %{"type" => "Reject", "object" => follow_object, "actor" => actor, "id" => id} = data
 353       ) do
 354     with actor <- get_actor(data),
 355          %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
 356          {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
 357          {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
 358          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
 359          {:ok, activity} <-
 360            ActivityPub.accept(%{
 361              to: follow_activity.data["to"],
 362              type: "Accept",
 363              actor: followed.ap_id,
 364              object: follow_activity.data["id"],
 365              local: false
 366            }) do
 367       User.unfollow(follower, followed)
 368
 369       {:ok, activity}
 370     else
 371       _e -> :error
 372     end
 373   end
 374
 375   def handle_incoming(
 376         %{"type" => "Like", "object" => object_id, "actor" => actor, "id" => id} = data
 377       ) do
 378     with actor <- get_actor(data),
 379          %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 380          {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
 381          {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
 382       {:ok, activity}
 383     else
 384       _e -> :error
 385     end
 386   end
 387
 388   def handle_incoming(
 389         %{"type" => "Announce", "object" => object_id, "actor" => actor, "id" => id} = data
 390       ) do
 391     with actor <- get_actor(data),
 392          %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 393          {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
 394          {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false) do
 395       {:ok, activity}
 396     else
 397       _e -> :error
 398     end
 399   end
 400
 401   def handle_incoming(
 402         %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
 403           data
 404       )
 405       when object_type in ["Person", "Application", "Service", "Organization"] do
 406     with %User{ap_id: ^actor_id} = actor <- User.get_by_ap_id(object["id"]) do
 407       {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
 408
 409       banner = new_user_data[:info]["banner"]
 410       locked = new_user_data[:info]["locked"] || false
 411
 412       update_data =
 413         new_user_data
 414         |> Map.take([:name, :bio, :avatar])
 415         |> Map.put(:info, Map.merge(actor.info, %{"banner" => banner, "locked" => locked}))
 416
 417       actor
 418       |> User.upgrade_changeset(update_data)
 419       |> User.update_and_set_cache()
 420
 421       ActivityPub.update(%{
 422         local: false,
 423         to: data["to"] || [],
 424         cc: data["cc"] || [],
 425         object: object,
 426         actor: actor_id
 427       })
 428     else
 429       e ->
 430         Logger.error(e)
 431         :error
 432     end
 433   end
 434
 435   # TODO: Make secure.
 436   def handle_incoming(
 437         %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => _id} = data
 438       ) do
 439     object_id = Utils.get_ap_id(object_id)
 440
 441     with actor <- get_actor(data),
 442          %User{} = _actor <- User.get_or_fetch_by_ap_id(actor),
 443          {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
 444          {:ok, activity} <- ActivityPub.delete(object, false) do
 445       {:ok, activity}
 446     else
 447       _e -> :error
 448     end
 449   end
 450
 451   def handle_incoming(
 452         %{
 453           "type" => "Undo",
 454           "object" => %{"type" => "Announce", "object" => object_id},
 455           "actor" => actor,
 456           "id" => id
 457         } = data
 458       ) do
 459     with actor <- get_actor(data),
 460          %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 461          {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
 462          {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
 463       {:ok, activity}
 464     else
 465       _e -> :error
 466     end
 467   end
 468
 469   def handle_incoming(
 470         %{
 471           "type" => "Undo",
 472           "object" => %{"type" => "Follow", "object" => followed},
 473           "actor" => follower,
 474           "id" => id
 475         } = _data
 476       ) do
 477     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 478          %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
 479          {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
 480       User.unfollow(follower, followed)
 481       {:ok, activity}
 482     else
 483       e -> :error
 484     end
 485   end
 486
 487   @ap_config Application.get_env(:pleroma, :activitypub)
 488   @accept_blocks Keyword.get(@ap_config, :accept_blocks)
 489
 490   def handle_incoming(
 491         %{
 492           "type" => "Undo",
 493           "object" => %{"type" => "Block", "object" => blocked},
 494           "actor" => blocker,
 495           "id" => id
 496         } = _data
 497       ) do
 498     with true <- @accept_blocks,
 499          %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
 500          %User{} = blocker <- User.get_or_fetch_by_ap_id(blocker),
 501          {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
 502       User.unblock(blocker, blocked)
 503       {:ok, activity}
 504     else
 505       e -> :error
 506     end
 507   end
 508
 509   def handle_incoming(
 510         %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = data
 511       ) do
 512     with true <- @accept_blocks,
 513          %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
 514          %User{} = blocker = User.get_or_fetch_by_ap_id(blocker),
 515          {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
 516       User.unfollow(blocker, blocked)
 517       User.block(blocker, blocked)
 518       {:ok, activity}
 519     else
 520       e -> :error
 521     end
 522   end
 523
 524   def handle_incoming(
 525         %{
 526           "type" => "Undo",
 527           "object" => %{"type" => "Like", "object" => object_id},
 528           "actor" => actor,
 529           "id" => id
 530         } = data
 531       ) do
 532     with actor <- get_actor(data),
 533          %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 534          {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
 535          {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
 536       {:ok, activity}
 537     else
 538       _e -> :error
 539     end
 540   end
 541
 542   def handle_incoming(_), do: :error
 543
 544   def fetch_obj_helper(id) when is_bitstring(id), do: ActivityPub.fetch_object_from_id(id)
 545   def fetch_obj_helper(obj) when is_map(obj), do: ActivityPub.fetch_object_from_id(obj["id"])
 546
 547   def get_obj_helper(id) do
 548     if object = Object.normalize(id), do: {:ok, object}, else: nil
 549   end
 550
 551   def set_reply_to_uri(%{"inReplyTo" => inReplyTo} = object) do
 552     with false <- String.starts_with?(inReplyTo, "http"),
 553          {:ok, %{data: replied_to_object}} <- get_obj_helper(inReplyTo) do
 554       Map.put(object, "inReplyTo", replied_to_object["external_url"] || inReplyTo)
 555     else
 556       _e -> object
 557     end
 558   end
 559
 560   def set_reply_to_uri(obj), do: obj
 561
 562   # Prepares the object of an outgoing create activity.
 563   def prepare_object(object) do
 564     object
 565     |> set_sensitive
 566     |> add_hashtags
 567     |> add_mention_tags
 568     |> add_emoji_tags
 569     |> add_attributed_to
 570     |> prepare_attachments
 571     |> set_conversation
 572     |> set_reply_to_uri
 573   end
 574
 575   #  @doc
 576   #  """
 577   #  internal -> Mastodon
 578   #  """
 579
 580   def prepare_outgoing(%{"type" => "Create", "object" => %{"type" => "Note"} = object} = data) do
 581     object =
 582       object
 583       |> prepare_object
 584
 585     data =
 586       data
 587       |> Map.put("object", object)
 588       |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 589
 590     {:ok, data}
 591   end
 592
 593   # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
 594   # because of course it does.
 595   def prepare_outgoing(%{"type" => "Accept"} = data) do
 596     with follow_activity <- Activity.normalize(data["object"]) do
 597       object = %{
 598         "actor" => follow_activity.actor,
 599         "object" => follow_activity.data["object"],
 600         "id" => follow_activity.data["id"],
 601         "type" => "Follow"
 602       }
 603
 604       data =
 605         data
 606         |> Map.put("object", object)
 607         |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 608
 609       {:ok, data}
 610     end
 611   end
 612
 613   def prepare_outgoing(%{"type" => "Reject"} = data) do
 614     with follow_activity <- Activity.normalize(data["object"]) do
 615       object = %{
 616         "actor" => follow_activity.actor,
 617         "object" => follow_activity.data["object"],
 618         "id" => follow_activity.data["id"],
 619         "type" => "Follow"
 620       }
 621
 622       data =
 623         data
 624         |> Map.put("object", object)
 625         |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 626
 627       {:ok, data}
 628     end
 629   end
 630
 631   def prepare_outgoing(%{"type" => _type} = data) do
 632     data =
 633       data
 634       |> maybe_fix_object_url
 635       |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 636
 637     {:ok, data}
 638   end
 639
 640   def maybe_fix_object_url(data) do
 641     if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
 642       case fetch_obj_helper(data["object"]) do
 643         {:ok, relative_object} ->
 644           if relative_object.data["external_url"] do
 645             _data =
 646               data
 647               |> Map.put("object", relative_object.data["external_url"])
 648           else
 649             data
 650           end
 651
 652         e ->
 653           Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
 654           data
 655       end
 656     else
 657       data
 658     end
 659   end
 660
 661   def add_hashtags(object) do
 662     tags =
 663       (object["tag"] || [])
 664       |> Enum.map(fn tag ->
 665         %{
 666           "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
 667           "name" => "##{tag}",
 668           "type" => "Hashtag"
 669         }
 670       end)
 671
 672     object
 673     |> Map.put("tag", tags)
 674   end
 675
 676   def add_mention_tags(object) do
 677     recipients = object["to"] ++ (object["cc"] || [])
 678
 679     mentions =
 680       recipients
 681       |> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
 682       |> Enum.filter(& &1)
 683       |> Enum.map(fn user ->
 684         %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
 685       end)
 686
 687     tags = object["tag"] || []
 688
 689     object
 690     |> Map.put("tag", tags ++ mentions)
 691   end
 692
 693   # TODO: we should probably send mtime instead of unix epoch time for updated
 694   def add_emoji_tags(object) do
 695     tags = object["tag"] || []
 696     emoji = object["emoji"] || []
 697
 698     out =
 699       emoji
 700       |> Enum.map(fn {name, url} ->
 701         %{
 702           "icon" => %{"url" => url, "type" => "Image"},
 703           "name" => ":" <> name <> ":",
 704           "type" => "Emoji",
 705           "updated" => "1970-01-01T00:00:00Z",
 706           "id" => url
 707         }
 708       end)
 709
 710     object
 711     |> Map.put("tag", tags ++ out)
 712   end
 713
 714   def set_conversation(object) do
 715     Map.put(object, "conversation", object["context"])
 716   end
 717
 718   def set_sensitive(object) do
 719     tags = object["tag"] || []
 720     Map.put(object, "sensitive", "nsfw" in tags)
 721   end
 722
 723   def add_attributed_to(object) do
 724     attributedTo = object["attributedTo"] || object["actor"]
 725
 726     object
 727     |> Map.put("attributedTo", attributedTo)
 728   end
 729
 730   def prepare_attachments(object) do
 731     attachments =
 732       (object["attachment"] || [])
 733       |> Enum.map(fn data ->
 734         [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
 735         %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
 736       end)
 737
 738     object
 739     |> Map.put("attachment", attachments)
 740   end
 741
 742   defp user_upgrade_task(user) do
 743     old_follower_address = User.ap_followers(user)
 744
 745     q =
 746       from(
 747         u in User,
 748         where: ^old_follower_address in u.following,
 749         update: [
 750           set: [
 751             following:
 752               fragment(
 753                 "array_replace(?,?,?)",
 754                 u.following,
 755                 ^old_follower_address,
 756                 ^user.follower_address
 757               )
 758           ]
 759         ]
 760       )
 761
 762     Repo.update_all(q, [])
 763
 764     maybe_retire_websub(user.ap_id)
 765
 766     # Only do this for recent activties, don't go through the whole db.
 767     # Only look at the last 1000 activities.
 768     since = (Repo.aggregate(Activity, :max, :id) || 0) - 1_000
 769
 770     q =
 771       from(
 772         a in Activity,
 773         where: ^old_follower_address in a.recipients,
 774         where: a.id > ^since,
 775         update: [
 776           set: [
 777             recipients:
 778               fragment(
 779                 "array_replace(?,?,?)",
 780                 a.recipients,
 781                 ^old_follower_address,
 782                 ^user.follower_address
 783               )
 784           ]
 785         ]
 786       )
 787
 788     Repo.update_all(q, [])
 789   end
 790
 791   def upgrade_user_from_ap_id(ap_id, async \\ true) do
 792     with %User{local: false} = user <- User.get_by_ap_id(ap_id),
 793          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
 794       data =
 795         data
 796         |> Map.put(:info, Map.merge(user.info, data[:info]))
 797
 798       already_ap = User.ap_enabled?(user)
 799
 800       {:ok, user} =
 801         User.upgrade_changeset(user, data)
 802         |> Repo.update()
 803
 804       if !already_ap do
 805         # This could potentially take a long time, do it in the background
 806         if async do
 807           Task.start(fn ->
 808             user_upgrade_task(user)
 809           end)
 810         else
 811           user_upgrade_task(user)
 812         end
 813       end
 814
 815       {:ok, user}
 816     else
 817       e -> e
 818     end
 819   end
 820
 821   def maybe_retire_websub(ap_id) do
 822     # some sanity checks
 823     if is_binary(ap_id) && String.length(ap_id) > 8 do
 824       q =
 825         from(
 826           ws in Pleroma.Web.Websub.WebsubClientSubscription,
 827           where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
 828         )
 829
 830       Repo.delete_all(q)
 831     end
 832   end
 833
 834   def maybe_fix_user_url(data) do
 835     if is_map(data["url"]) do
 836       Map.put(data, "url", data["url"]["href"])
 837     else
 838       data
 839     end
 840   end
 841
 842   def maybe_fix_user_object(data) do
 843     data
 844     |> maybe_fix_user_url
 845   end
 846 end