1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.ActivityPub.Transmogrifier do
7 A module to handle coding from internal to wire ActivityPub and back.
11 alias Pleroma.Object.Containment
14 alias Pleroma.Web.ActivityPub.ActivityPub
15 alias Pleroma.Web.ActivityPub.Utils
16 alias Pleroma.Web.ActivityPub.Visibility
17 alias Pleroma.Web.Federator
22 require Pleroma.Constants
25 Modifies an incoming AP object (mastodon format) to our internal format.
27 def fix_object(object, options \\ []) do
29 |> strip_internal_fields
34 |> fix_in_reply_to(options)
43 def fix_summary(%{"summary" => nil} = object) do
44 Map.put(object, "summary", "")
47 def fix_summary(%{"summary" => _} = object) do
48 # summary is present, nothing to do
52 def fix_summary(object), do: Map.put(object, "summary", "")
54 def fix_addressing_list(map, field) do
56 is_binary(map[field]) ->
57 Map.put(map, field, [map[field]])
60 Map.put(map, field, [])
67 def fix_explicit_addressing(
68 %{"to" => to, "cc" => cc} = object,
72 explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
74 explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
78 |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
82 |> Map.put("to", explicit_to)
83 |> Map.put("cc", final_cc)
86 def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
88 # if directMessage flag is set to true, leave the addressing alone
89 def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
91 def fix_explicit_addressing(object) do
92 explicit_mentions = Utils.determine_explicit_mentions(object)
94 %User{follower_address: follower_collection} =
96 |> Containment.get_actor()
97 |> User.get_cached_by_ap_id()
102 Pleroma.Constants.as_public(),
106 fix_explicit_addressing(object, explicit_mentions, follower_collection)
109 # if as:Public is addressed, then make sure the followers collection is also addressed
110 # so that the activities will be delivered to local users.
111 def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
112 recipients = to ++ cc
114 if followers_collection not in recipients do
116 Pleroma.Constants.as_public() in cc ->
117 to = to ++ [followers_collection]
118 Map.put(object, "to", to)
120 Pleroma.Constants.as_public() in to ->
121 cc = cc ++ [followers_collection]
122 Map.put(object, "cc", cc)
132 def fix_implicit_addressing(object, _), do: object
134 def fix_addressing(object) do
135 {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
136 followers_collection = User.ap_followers(user)
139 |> fix_addressing_list("to")
140 |> fix_addressing_list("cc")
141 |> fix_addressing_list("bto")
142 |> fix_addressing_list("bcc")
143 |> fix_explicit_addressing()
144 |> fix_implicit_addressing(followers_collection)
147 def fix_actor(%{"attributedTo" => actor} = object) do
148 Map.put(object, "actor", Containment.get_actor(%{"actor" => actor}))
151 def fix_in_reply_to(object, options \\ [])
153 def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
154 when not is_nil(in_reply_to) do
155 in_reply_to_id = prepare_in_reply_to(in_reply_to)
156 object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
158 if Federator.allowed_incoming_reply_depth?(options[:depth]) do
159 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
160 %Activity{} = _ <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
162 |> Map.put("inReplyTo", replied_object.data["id"])
163 |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
164 |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
165 |> Map.put("context", replied_object.data["context"] || object["conversation"])
168 Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
176 def fix_in_reply_to(object, _options), do: object
178 defp prepare_in_reply_to(in_reply_to) do
180 is_bitstring(in_reply_to) ->
183 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
186 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
187 Enum.at(in_reply_to, 0)
194 def fix_context(object) do
195 context = object["context"] || object["conversation"] || Utils.generate_context_id()
198 |> Map.put("context", context)
199 |> Map.put("conversation", context)
202 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
204 Enum.map(attachment, fn data ->
205 media_type = data["mediaType"] || data["mimeType"]
206 href = data["url"] || data["href"]
207 url = [%{"type" => "Link", "mediaType" => media_type, "href" => href}]
210 |> Map.put("mediaType", media_type)
211 |> Map.put("url", url)
214 Map.put(object, "attachment", attachments)
217 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
219 |> Map.put("attachment", [attachment])
223 def fix_attachments(object), do: object
225 def fix_url(%{"url" => url} = object) when is_map(url) do
226 Map.put(object, "url", url["href"])
229 def fix_url(%{"type" => "Video", "url" => url} = object) when is_list(url) do
230 first_element = Enum.at(url, 0)
232 link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)
235 |> Map.put("attachment", [first_element])
236 |> Map.put("url", link_element["href"])
239 def fix_url(%{"type" => object_type, "url" => url} = object)
240 when object_type != "Video" and is_list(url) do
241 first_element = Enum.at(url, 0)
245 is_bitstring(first_element) -> first_element
246 is_map(first_element) -> first_element["href"] || ""
250 Map.put(object, "url", url_string)
253 def fix_url(object), do: object
255 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
258 |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
259 |> Enum.reduce(%{}, fn data, mapping ->
260 name = String.trim(data["name"], ":")
262 Map.put(mapping, name, data["icon"]["url"])
265 # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
266 emoji = Map.merge(object["emoji"] || %{}, emoji)
268 Map.put(object, "emoji", emoji)
271 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
272 name = String.trim(tag["name"], ":")
273 emoji = %{name => tag["icon"]["url"]}
275 Map.put(object, "emoji", emoji)
278 def fix_emoji(object), do: object
280 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
283 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
284 |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
286 Map.put(object, "tag", tag ++ tags)
289 def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
290 combined = [tag, String.slice(hashtag, 1..-1)]
292 Map.put(object, "tag", combined)
295 def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
297 def fix_tag(object), do: object
299 # content map usually only has one language so this will do for now.
300 def fix_content_map(%{"contentMap" => content_map} = object) do
301 content_groups = Map.to_list(content_map)
302 {_, content} = Enum.at(content_groups, 0)
304 Map.put(object, "content", content)
307 def fix_content_map(object), do: object
309 def fix_type(object, options \\ [])
311 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
312 when is_binary(reply_id) do
313 with true <- Federator.allowed_incoming_reply_depth?(options[:depth]),
314 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
315 Map.put(object, "type", "Answer")
321 def fix_type(object, _), do: object
323 defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
324 with true <- id =~ "follows",
325 %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
326 %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
333 defp mastodon_follow_hack(_, _), do: {:error, nil}
335 defp get_follow_activity(follow_object, followed) do
336 with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
337 {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
340 # Can't find the activity. This might a Mastodon 2.3 "Accept"
342 mastodon_follow_hack(follow_object, followed)
349 # Reduce the object list to find the reported user.
350 defp get_reported(objects) do
351 Enum.reduce_while(objects, nil, fn ap_id, _ ->
352 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
360 def handle_incoming(data, options \\ [])
362 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
364 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
365 with context <- data["context"] || Utils.generate_context_id(),
366 content <- data["content"] || "",
367 %User{} = actor <- User.get_cached_by_ap_id(actor),
368 # Reduce the object list to find the reported user.
369 %User{} = account <- get_reported(objects),
370 # Remove the reported user from the object list.
371 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
378 additional: %{"cc" => [account.ap_id]}
380 |> ActivityPub.flag()
384 # disallow objects with bogus IDs
385 def handle_incoming(%{"id" => nil}, _options), do: :error
386 def handle_incoming(%{"id" => ""}, _options), do: :error
387 # length of https:// = 8, should validate better, but good enough for now.
388 def handle_incoming(%{"id" => id}, _options) when not (is_binary(id) and length(id) > 8),
391 # TODO: validate those with a Ecto scheme
395 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
398 when objtype in ["Article", "Note", "Video", "Page", "Question", "Answer"] do
399 actor = Containment.get_actor(data)
402 Map.put(data, "actor", actor)
405 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
406 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
407 options = Keyword.put(options, :depth, (options[:depth] || 0) + 1)
408 object = fix_object(data["object"], options)
414 context: object["conversation"],
416 published: data["published"],
425 ActivityPub.create(params)
427 %Activity{} = activity -> {:ok, activity}
433 %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
436 with %User{local: true} = followed <-
437 User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
438 {:ok, %User{} = follower} <-
439 User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
440 {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
441 with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
442 {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
443 {_, false} <- {:user_locked, User.locked?(followed)},
444 {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
446 {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")} do
447 ActivityPub.accept(%{
448 to: [follower.ap_id],
454 {:user_blocked, true} ->
455 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
457 ActivityPub.reject(%{
458 to: [follower.ap_id],
464 {:follow, {:error, _}} ->
465 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
467 ActivityPub.reject(%{
468 to: [follower.ap_id],
474 {:user_locked, true} ->
486 %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data,
489 with actor <- Containment.get_actor(data),
490 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
491 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
492 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
493 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
494 {:ok, _follower} = User.follow(follower, followed) do
495 ActivityPub.accept(%{
496 to: follow_activity.data["to"],
499 object: follow_activity.data["id"],
508 %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data,
511 with actor <- Containment.get_actor(data),
512 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
513 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
514 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
515 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
517 ActivityPub.reject(%{
518 to: follow_activity.data["to"],
521 object: follow_activity.data["id"],
524 User.unfollow(follower, followed)
533 %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data,
536 with actor <- Containment.get_actor(data),
537 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
538 {:ok, object} <- get_obj_helper(object_id),
539 {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
547 %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
550 with actor <- Containment.get_actor(data),
551 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
552 {:ok, object} <- get_obj_helper(object_id),
553 public <- Visibility.is_public?(data),
554 {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
562 %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
566 when object_type in ["Person", "Application", "Service", "Organization"] do
567 with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
568 {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
570 banner = new_user_data[:info][:banner]
571 locked = new_user_data[:info][:locked] || false
572 attachment = get_in(new_user_data, [:info, :source_data, "attachment"]) || []
576 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
577 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
581 |> Map.take([:name, :bio, :avatar])
582 |> Map.put(:info, %{banner: banner, locked: locked, fields: fields})
585 |> User.upgrade_changeset(update_data, true)
586 |> User.update_and_set_cache()
588 ActivityPub.update(%{
590 to: data["to"] || [],
591 cc: data["cc"] || [],
602 # TODO: We presently assume that any actor on the same origin domain as the object being
603 # deleted has the rights to delete that object. A better way to validate whether or not
604 # the object should be deleted is to refetch the object URI, which should return either
605 # an error or a tombstone. This would allow us to verify that a deletion actually took
608 %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => _id} = data,
611 object_id = Utils.get_ap_id(object_id)
613 with actor <- Containment.get_actor(data),
614 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
615 {:ok, object} <- get_obj_helper(object_id),
616 :ok <- Containment.contain_origin(actor.ap_id, object.data),
617 {:ok, activity} <- ActivityPub.delete(object, false) do
621 case User.get_cached_by_ap_id(object_id) do
622 %User{ap_id: ^actor} = user ->
637 "object" => %{"type" => "Announce", "object" => object_id},
643 with actor <- Containment.get_actor(data),
644 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
645 {:ok, object} <- get_obj_helper(object_id),
646 {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
656 "object" => %{"type" => "Follow", "object" => followed},
662 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
663 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
664 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
665 User.unfollow(follower, followed)
675 "object" => %{"type" => "Block", "object" => blocked},
681 with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
682 {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
683 {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
684 User.unblock(blocker, blocked)
692 %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
695 with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
696 {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
697 {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
698 User.unfollow(blocker, blocked)
699 User.block(blocker, blocked)
709 "object" => %{"type" => "Like", "object" => object_id},
715 with actor <- Containment.get_actor(data),
716 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
717 {:ok, object} <- get_obj_helper(object_id),
718 {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
725 def handle_incoming(_, _), do: :error
727 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
728 def get_obj_helper(id, options \\ []) do
729 case Object.normalize(id, true, options) do
730 %Object{} = object -> {:ok, object}
735 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
736 with false <- String.starts_with?(in_reply_to, "http"),
737 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
738 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
744 def set_reply_to_uri(obj), do: obj
746 # Prepares the object of an outgoing create activity.
747 def prepare_object(object) do
754 |> prepare_attachments
757 |> strip_internal_fields
758 |> strip_internal_tags
764 # internal -> Mastodon
767 def prepare_outgoing(%{"type" => "Create", "object" => object_id} = data) do
770 |> Object.normalize()
776 |> Map.put("object", object)
777 |> Map.merge(Utils.make_json_ld_header())
783 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
784 # because of course it does.
785 def prepare_outgoing(%{"type" => "Accept"} = data) do
786 with follow_activity <- Activity.normalize(data["object"]) do
788 "actor" => follow_activity.actor,
789 "object" => follow_activity.data["object"],
790 "id" => follow_activity.data["id"],
796 |> Map.put("object", object)
797 |> Map.merge(Utils.make_json_ld_header())
803 def prepare_outgoing(%{"type" => "Reject"} = data) do
804 with follow_activity <- Activity.normalize(data["object"]) do
806 "actor" => follow_activity.actor,
807 "object" => follow_activity.data["object"],
808 "id" => follow_activity.data["id"],
814 |> Map.put("object", object)
815 |> Map.merge(Utils.make_json_ld_header())
821 def prepare_outgoing(%{"type" => _type} = data) do
824 |> strip_internal_fields
825 |> maybe_fix_object_url
826 |> Map.merge(Utils.make_json_ld_header())
831 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
832 with false <- String.starts_with?(object, "http"),
833 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
834 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
836 Map.put(data, "object", external_url)
839 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
847 def maybe_fix_object_url(data), do: data
849 def add_hashtags(object) do
851 (object["tag"] || [])
853 # Expand internal representation tags into AS2 tags.
854 tag when is_binary(tag) ->
856 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
861 # Do not process tags which are already AS2 tag objects.
862 tag when is_map(tag) ->
866 Map.put(object, "tag", tags)
869 def add_mention_tags(object) do
872 |> Utils.get_notified_from_object()
873 |> Enum.map(&build_mention_tag/1)
875 tags = object["tag"] || []
877 Map.put(object, "tag", tags ++ mentions)
880 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
881 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
884 def take_emoji_tags(%User{info: %{emoji: emoji} = _user_info} = _user) do
886 |> Enum.flat_map(&Map.to_list/1)
887 |> Enum.map(&build_emoji_tag/1)
890 # TODO: we should probably send mtime instead of unix epoch time for updated
891 def add_emoji_tags(%{"emoji" => emoji} = object) do
892 tags = object["tag"] || []
894 out = Enum.map(emoji, &build_emoji_tag/1)
896 Map.put(object, "tag", tags ++ out)
899 def add_emoji_tags(object), do: object
901 defp build_emoji_tag({name, url}) do
903 "icon" => %{"url" => url, "type" => "Image"},
904 "name" => ":" <> name <> ":",
906 "updated" => "1970-01-01T00:00:00Z",
911 def set_conversation(object) do
912 Map.put(object, "conversation", object["context"])
915 def set_sensitive(object) do
916 tags = object["tag"] || []
917 Map.put(object, "sensitive", "nsfw" in tags)
920 def set_type(%{"type" => "Answer"} = object) do
921 Map.put(object, "type", "Note")
924 def set_type(object), do: object
926 def add_attributed_to(object) do
927 attributed_to = object["attributedTo"] || object["actor"]
928 Map.put(object, "attributedTo", attributed_to)
931 def prepare_attachments(object) do
933 (object["attachment"] || [])
934 |> Enum.map(fn data ->
935 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
936 %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
939 Map.put(object, "attachment", attachments)
942 defp strip_internal_fields(object) do
948 "announcement_count",
951 "deleted_activity_id"
955 defp strip_internal_tags(%{"tag" => tags} = object) do
956 tags = Enum.filter(tags, fn x -> is_map(x) end)
958 Map.put(object, "tag", tags)
961 defp strip_internal_tags(object), do: object
963 def perform(:user_upgrade, user) do
964 # we pass a fake user so that the followers collection is stripped away
965 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
970 where: ^old_follower_address in u.following,
975 "array_replace(?,?,?)",
977 ^old_follower_address,
978 ^user.follower_address
984 Repo.update_all(q, [])
986 maybe_retire_websub(user.ap_id)
991 where: ^old_follower_address in a.recipients,
996 "array_replace(?,?,?)",
998 ^old_follower_address,
999 ^user.follower_address
1005 Repo.update_all(q, [])
1008 def upgrade_user_from_ap_id(ap_id) do
1009 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1010 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1011 already_ap <- User.ap_enabled?(user),
1012 {:ok, user} <- user |> User.upgrade_changeset(data) |> User.update_and_set_cache() do
1013 unless already_ap do
1014 PleromaJobQueue.enqueue(:transmogrifier, __MODULE__, [:user_upgrade, user])
1019 %User{} = user -> {:ok, user}
1024 def maybe_retire_websub(ap_id) do
1025 # some sanity checks
1026 if is_binary(ap_id) && String.length(ap_id) > 8 do
1029 ws in Pleroma.Web.Websub.WebsubClientSubscription,
1030 where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
1037 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1038 Map.put(data, "url", url["href"])
1041 def maybe_fix_user_url(data), do: data
1043 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)