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

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