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