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