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