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