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