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