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