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