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
  11   import Ecto.Query
  12
  13   require Logger
  14
  15   @doc """
  16   Modifies an incoming AP object (mastodon format) to our internal format.
  17   """
  18   def fix_object(object) do
  19     object
  20     |> Map.put("actor", object["attributedTo"])
  21     |> fix_attachments
  22     |> fix_context
  23     |> fix_in_reply_to
  24   end
  25
  26   def fix_in_reply_to(%{"inReplyTo" => in_reply_to_id} = object) when not is_nil(in_reply_to_id) do
  27     case ActivityPub.fetch_object_from_id(in_reply_to_id) do
  28       {:ok, replied_object} ->
  29         activity = Activity.get_create_activity_by_object_ap_id(replied_object.data["id"])
  30         object
  31         |> Map.put("inReplyTo", replied_object.data["id"])
  32         |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
  33         |> Map.put("inReplyToStatusId", activity.id)
  34         |> Map.put("conversation", replied_object.data["conversation"])
  35         |> Map.put("context", replied_object.data["conversation"])
  36       e ->
  37         Logger.error("Couldn't fetch #{object["inReplyTo"]} #{inspect(e)}")
  38         object
  39     end
  40   end
  41   def fix_in_reply_to(object), do: object
  42
  43   def fix_context(object) do
  44     object
  45     |> Map.put("context", object["conversation"])
  46   end
  47
  48   def fix_attachments(object) do
  49     attachments = (object["attachment"] || [])
  50     |> Enum.map(fn (data) ->
  51       url = [%{"type" => "Link", "mediaType" => data["mediaType"], "href" => data["url"]}]
  52       Map.put(data, "url", url)
  53     end)
  54
  55     object
  56     |> Map.put("attachment", attachments)
  57   end
  58
  59   # TODO: validate those with a Ecto scheme
  60   # - tags
  61   # - emoji
  62   def handle_incoming(%{"type" => "Create", "object" => %{"type" => "Note"} = object} = data) do
  63     with nil <- Activity.get_create_activity_by_object_ap_id(object["id"]),
  64          %User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
  65       object = fix_object(data["object"])
  66
  67       params = %{
  68         to: data["to"],
  69         object: object,
  70         actor: user,
  71         context: data["object"]["conversation"],
  72         local: false,
  73         published: data["published"],
  74         additional: Map.take(data, [
  75               "cc",
  76               "id"
  77             ])
  78       }
  79
  80
  81       ActivityPub.create(params)
  82     else
  83       %Activity{} = activity -> {:ok, activity}
  84       _e -> :error
  85     end
  86   end
  87
  88   def handle_incoming(%{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data) do
  89     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
  90          %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
  91          {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
  92       ActivityPub.accept(%{to: [follower.ap_id], actor: followed.ap_id, object: data, local: true})
  93       User.follow(follower, followed)
  94       {:ok, activity}
  95     else
  96       _e -> :error
  97     end
  98   end
  99
 100   def handle_incoming(%{"type" => "Like", "object" => object_id, "actor" => actor, "id" => id} = data) do
 101     with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 102          {:ok, object} <- get_obj_helper(object_id) || ActivityPub.fetch_object_from_id(object_id),
 103          {:ok, activity, object} <- ActivityPub.like(actor, object, id, false) do
 104       {:ok, activity}
 105     else
 106       _e -> :error
 107     end
 108   end
 109
 110   def handle_incoming(%{"type" => "Announce", "object" => object_id, "actor" => actor, "id" => id} = data) do
 111     with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 112          {:ok, object} <- get_obj_helper(object_id) || ActivityPub.fetch_object_from_id(object_id),
 113          {:ok, activity, object} <- ActivityPub.announce(actor, object, id, false) do
 114       {:ok, activity}
 115     else
 116       _e -> :error
 117     end
 118   end
 119
 120   def handle_incoming(%{"type" => "Update", "object" => %{"type" => "Person"} = object, "actor" => actor_id} = data) do
 121     with %User{ap_id: ^actor_id} = actor <- User.get_by_ap_id(object["id"]) do
 122       {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
 123
 124       banner = new_user_data[:info]["banner"]
 125       update_data = new_user_data
 126       |> Map.take([:name, :bio, :avatar])
 127       |> Map.put(:info, Map.merge(actor.info, %{"banner" => banner}))
 128
 129       actor
 130       |> User.upgrade_changeset(update_data)
 131       |> Repo.update
 132
 133       User.invalidate_cache(actor)
 134       ActivityPub.update(%{local: false, to: data["to"] || [], cc: data["cc"] || [], object: object, actor: actor_id})
 135     else
 136       e ->
 137         Logger.error(e)
 138         :error
 139     end
 140   end
 141
 142   # TODO
 143   # Accept
 144   # Undo
 145
 146   def handle_incoming(_), do: :error
 147
 148   def get_obj_helper(id) do
 149     if object = Object.get_by_ap_id(id), do: {:ok, object}, else: nil
 150   end
 151
 152   def prepare_object(object) do
 153     object
 154     |> set_sensitive
 155     |> add_hashtags
 156     |> add_mention_tags
 157     |> add_attributed_to
 158     |> prepare_attachments
 159     |> set_conversation
 160   end
 161
 162   @doc
 163   """
 164   internal -> Mastodon
 165   """
 166   def prepare_outgoing(%{"type" => "Create", "object" => %{"type" => "Note"} = object} = data) do
 167     object = object
 168     |> prepare_object
 169     data = data
 170     |> Map.put("object", object)
 171     |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 172
 173     {:ok, data}
 174   end
 175
 176   def prepare_outgoing(%{"type" => type} = data) do
 177     data = data
 178     |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 179
 180     {:ok, data}
 181   end
 182
 183   def add_hashtags(object) do
 184     tags = (object["tag"] || [])
 185     |> Enum.map fn (tag) -> %{"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}", "name" => "##{tag}", "type" => "Hashtag"} end
 186
 187     object
 188     |> Map.put("tag", tags)
 189   end
 190
 191   def add_mention_tags(object) do
 192     recipients = object["to"] ++ (object["cc"] || [])
 193     mentions = recipients
 194     |> Enum.map(fn (ap_id) -> User.get_cached_by_ap_id(ap_id) end)
 195     |> Enum.filter(&(&1))
 196     |> Enum.map(fn(user) -> %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"} end)
 197
 198     tags = object["tag"] || []
 199
 200     object
 201     |> Map.put("tag", tags ++ mentions)
 202   end
 203
 204   def set_conversation(object) do
 205     Map.put(object, "conversation", object["context"])
 206   end
 207
 208   def set_sensitive(object) do
 209     tags = object["tag"] || []
 210     Map.put(object, "sensitive", "nsfw" in tags)
 211   end
 212
 213   def add_attributed_to(object) do
 214     attributedTo = object["attributedTo"] || object["actor"]
 215
 216     object
 217     |> Map.put("attributedTo", attributedTo)
 218   end
 219
 220   def prepare_attachments(object) do
 221     attachments = (object["attachment"] || [])
 222     |> Enum.map(fn (data) ->
 223       [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
 224       %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
 225     end)
 226
 227     object
 228     |> Map.put("attachment", attachments)
 229   end
 230
 231   defp user_upgrade_task(user) do
 232     old_follower_address = User.ap_followers(user)
 233     q  = from u in User,
 234     where: ^old_follower_address in u.following,
 235     update: [set: [following: fragment("array_replace(?,?,?)", u.following, ^old_follower_address, ^user.follower_address)]]
 236     Repo.update_all(q, [])
 237
 238     maybe_retire_websub(user.ap_id)
 239
 240     # Only do this for recent activties, don't go through the whole db.
 241     since = (Repo.aggregate(Activity, :max, :id) || 0) - 100_000
 242     q  = from a in Activity,
 243     where: ^old_follower_address in a.recipients,
 244     where: a.id > ^since,
 245     update: [set: [recipients: fragment("array_replace(?,?,?)", a.recipients, ^old_follower_address, ^user.follower_address)]]
 246     Repo.update_all(q, [])
 247   end
 248
 249   def upgrade_user_from_ap_id(ap_id, async \\ true) do
 250     with %User{local: false} = user <- User.get_by_ap_id(ap_id),
 251          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
 252       data = data
 253       |> Map.put(:info, Map.merge(user.info, data[:info]))
 254
 255       {:ok, user} = User.upgrade_changeset(user, data)
 256       |> Repo.update()
 257
 258       # This could potentially take a long time, do it in the background
 259       if async do
 260         Task.start(fn ->
 261           user_upgrade_task(user)
 262         end)
 263       else
 264         user_upgrade_task(user)
 265       end
 266
 267       {:ok, user}
 268     else
 269       e -> e
 270     end
 271   end
 272
 273   def maybe_retire_websub(ap_id) do
 274     # some sanity checks
 275     if is_binary(ap_id) && (String.length(ap_id) > 8) do
 276       q = from ws in Pleroma.Web.Websub.WebsubClientSubscription,
 277         where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
 278       Repo.delete_all(q)
 279     end
 280   end
 281 end