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" => "Note"} = object} = data) 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.normalize(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     with follow_activity <- Activity.normalize(data["object"]) do
 464       object = %{
 465         "actor" => follow_activity.actor,
 466         "object" => follow_activity.data["object"],
 467         "id" => follow_activity.data["id"],
 468         "type" => "Follow"
 469       }
 470
 471       data =
 472         data
 473         |> Map.put("object", object)
 474         |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 475
 476       {:ok, data}
 477     end
 478   end
 479
 480   def prepare_outgoing(%{"type" => "Reject"} = data) do
 481     with follow_activity <- Activity.normalize(data["object"]) do
 482       object = %{
 483         "actor" => follow_activity.actor,
 484         "object" => follow_activity.data["object"],
 485         "id" => follow_activity.data["id"],
 486         "type" => "Follow"
 487       }
 488
 489       data =
 490         data
 491         |> Map.put("object", object)
 492         |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 493
 494       {:ok, data}
 495     end
 496   end
 497
 498   def prepare_outgoing(%{"type" => _type} = data) do
 499     data =
 500       data
 501       |> maybe_fix_object_url
 502       |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 503
 504     {:ok, data}
 505   end
 506
 507   def maybe_fix_object_url(data) do
 508     if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
 509       case ActivityPub.fetch_object_from_id(data["object"]) do
 510         {:ok, relative_object} ->
 511           if relative_object.data["external_url"] do
 512             _data =
 513               data
 514               |> Map.put("object", relative_object.data["external_url"])
 515           else
 516             data
 517           end
 518
 519         e ->
 520           Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
 521           data
 522       end
 523     else
 524       data
 525     end
 526   end
 527
 528   def add_hashtags(object) do
 529     tags =
 530       (object["tag"] || [])
 531       |> Enum.map(fn tag ->
 532         %{
 533           "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
 534           "name" => "##{tag}",
 535           "type" => "Hashtag"
 536         }
 537       end)
 538
 539     object
 540     |> Map.put("tag", tags)
 541   end
 542
 543   def add_mention_tags(object) do
 544     recipients = object["to"] ++ (object["cc"] || [])
 545
 546     mentions =
 547       recipients
 548       |> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
 549       |> Enum.filter(& &1)
 550       |> Enum.map(fn user ->
 551         %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
 552       end)
 553
 554     tags = object["tag"] || []
 555
 556     object
 557     |> Map.put("tag", tags ++ mentions)
 558   end
 559
 560   # TODO: we should probably send mtime instead of unix epoch time for updated
 561   def add_emoji_tags(object) do
 562     tags = object["tag"] || []
 563     emoji = object["emoji"] || []
 564
 565     out =
 566       emoji
 567       |> Enum.map(fn {name, url} ->
 568         %{
 569           "icon" => %{"url" => url, "type" => "Image"},
 570           "name" => ":" <> name <> ":",
 571           "type" => "Emoji",
 572           "updated" => "1970-01-01T00:00:00Z",
 573           "id" => url
 574         }
 575       end)
 576
 577     object
 578     |> Map.put("tag", tags ++ out)
 579   end
 580
 581   def set_conversation(object) do
 582     Map.put(object, "conversation", object["context"])
 583   end
 584
 585   def set_sensitive(object) do
 586     tags = object["tag"] || []
 587     Map.put(object, "sensitive", "nsfw" in tags)
 588   end
 589
 590   def add_attributed_to(object) do
 591     attributedTo = object["attributedTo"] || object["actor"]
 592
 593     object
 594     |> Map.put("attributedTo", attributedTo)
 595   end
 596
 597   def prepare_attachments(object) do
 598     attachments =
 599       (object["attachment"] || [])
 600       |> Enum.map(fn data ->
 601         [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
 602         %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
 603       end)
 604
 605     object
 606     |> Map.put("attachment", attachments)
 607   end
 608
 609   defp user_upgrade_task(user) do
 610     old_follower_address = User.ap_followers(user)
 611
 612     q =
 613       from(
 614         u in User,
 615         where: ^old_follower_address in u.following,
 616         update: [
 617           set: [
 618             following:
 619               fragment(
 620                 "array_replace(?,?,?)",
 621                 u.following,
 622                 ^old_follower_address,
 623                 ^user.follower_address
 624               )
 625           ]
 626         ]
 627       )
 628
 629     Repo.update_all(q, [])
 630
 631     maybe_retire_websub(user.ap_id)
 632
 633     # Only do this for recent activties, don't go through the whole db.
 634     # Only look at the last 1000 activities.
 635     since = (Repo.aggregate(Activity, :max, :id) || 0) - 1_000
 636
 637     q =
 638       from(
 639         a in Activity,
 640         where: ^old_follower_address in a.recipients,
 641         where: a.id > ^since,
 642         update: [
 643           set: [
 644             recipients:
 645               fragment(
 646                 "array_replace(?,?,?)",
 647                 a.recipients,
 648                 ^old_follower_address,
 649                 ^user.follower_address
 650               )
 651           ]
 652         ]
 653       )
 654
 655     Repo.update_all(q, [])
 656   end
 657
 658   def upgrade_user_from_ap_id(ap_id, async \\ true) do
 659     with %User{local: false} = user <- User.get_by_ap_id(ap_id),
 660          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
 661       data =
 662         data
 663         |> Map.put(:info, Map.merge(user.info, data[:info]))
 664
 665       already_ap = User.ap_enabled?(user)
 666
 667       {:ok, user} =
 668         User.upgrade_changeset(user, data)
 669         |> Repo.update()
 670
 671       if !already_ap do
 672         # This could potentially take a long time, do it in the background
 673         if async do
 674           Task.start(fn ->
 675             user_upgrade_task(user)
 676           end)
 677         else
 678           user_upgrade_task(user)
 679         end
 680       end
 681
 682       {:ok, user}
 683     else
 684       e -> e
 685     end
 686   end
 687
 688   def maybe_retire_websub(ap_id) do
 689     # some sanity checks
 690     if is_binary(ap_id) && String.length(ap_id) > 8 do
 691       q =
 692         from(
 693           ws in Pleroma.Web.Websub.WebsubClientSubscription,
 694           where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
 695         )
 696
 697       Repo.delete_all(q)
 698     end
 699   end
 700
 701   def maybe_fix_user_url(data) do
 702     if is_map(data["url"]) do
 703       Map.put(data, "url", data["url"]["href"])
 704     else
 705       data
 706     end
 707   end
 708
 709   def maybe_fix_user_object(data) do
 710     data
 711     |> maybe_fix_user_url
 712   end
 713 end