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