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