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["context"] || object["conversation"])
  35         |> Map.put("context", replied_object.data["context"] || object["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: 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       |> User.update_and_set_cache()
 132
 133       ActivityPub.update(%{local: false, to: data["to"] || [], cc: data["cc"] || [], object: object, actor: actor_id})
 134     else
 135       e ->
 136         Logger.error(e)
 137         :error
 138     end
 139   end
 140
 141   # TODO: Make secure.
 142   def handle_incoming(%{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data) do
 143     object_id = case object_id do
 144                   %{"id" => id} -> id
 145                   id -> id
 146                 end
 147     with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 148          {:ok, object} <- get_obj_helper(object_id) || ActivityPub.fetch_object_from_id(object_id),
 149          {:ok, activity} <- ActivityPub.delete(object, false) do
 150       {:ok, activity}
 151     else
 152       e -> :error
 153     end
 154   end
 155
 156   # TODO
 157   # Accept
 158   # Undo
 159
 160   def handle_incoming(_), do: :error
 161
 162   def get_obj_helper(id) do
 163     if object = Object.get_by_ap_id(id), do: {:ok, object}, else: nil
 164   end
 165
 166   def prepare_object(object) do
 167     object
 168     |> set_sensitive
 169     |> add_hashtags
 170     |> add_mention_tags
 171     |> add_attributed_to
 172     |> prepare_attachments
 173     |> set_conversation
 174   end
 175
 176   @doc
 177   """
 178   internal -> Mastodon
 179   """
 180   def prepare_outgoing(%{"type" => "Create", "object" => %{"type" => "Note"} = object} = data) do
 181     object = object
 182     |> prepare_object
 183     data = data
 184     |> Map.put("object", object)
 185     |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 186
 187     {:ok, data}
 188   end
 189
 190   def prepare_outgoing(%{"type" => type} = data) do
 191     data = data
 192     |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 193
 194     {:ok, data}
 195   end
 196
 197   def add_hashtags(object) do
 198     tags = (object["tag"] || [])
 199     |> Enum.map fn (tag) -> %{"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}", "name" => "##{tag}", "type" => "Hashtag"} end
 200
 201     object
 202     |> Map.put("tag", tags)
 203   end
 204
 205   def add_mention_tags(object) do
 206     recipients = object["to"] ++ (object["cc"] || [])
 207     mentions = recipients
 208     |> Enum.map(fn (ap_id) -> User.get_cached_by_ap_id(ap_id) end)
 209     |> Enum.filter(&(&1))
 210     |> Enum.map(fn(user) -> %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"} end)
 211
 212     tags = object["tag"] || []
 213
 214     object
 215     |> Map.put("tag", tags ++ mentions)
 216   end
 217
 218   def set_conversation(object) do
 219     Map.put(object, "conversation", object["context"])
 220   end
 221
 222   def set_sensitive(object) do
 223     tags = object["tag"] || []
 224     Map.put(object, "sensitive", "nsfw" in tags)
 225   end
 226
 227   def add_attributed_to(object) do
 228     attributedTo = object["attributedTo"] || object["actor"]
 229
 230     object
 231     |> Map.put("attributedTo", attributedTo)
 232   end
 233
 234   def prepare_attachments(object) do
 235     attachments = (object["attachment"] || [])
 236     |> Enum.map(fn (data) ->
 237       [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
 238       %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
 239     end)
 240
 241     object
 242     |> Map.put("attachment", attachments)
 243   end
 244
 245   defp user_upgrade_task(user) do
 246     old_follower_address = User.ap_followers(user)
 247     q  = from u in User,
 248     where: ^old_follower_address in u.following,
 249     update: [set: [following: fragment("array_replace(?,?,?)", u.following, ^old_follower_address, ^user.follower_address)]]
 250     Repo.update_all(q, [])
 251
 252     maybe_retire_websub(user.ap_id)
 253
 254     # Only do this for recent activties, don't go through the whole db.
 255     since = (Repo.aggregate(Activity, :max, :id) || 0) - 100_000
 256     q  = from a in Activity,
 257     where: ^old_follower_address in a.recipients,
 258     where: a.id > ^since,
 259     update: [set: [recipients: fragment("array_replace(?,?,?)", a.recipients, ^old_follower_address, ^user.follower_address)]]
 260     Repo.update_all(q, [])
 261   end
 262
 263   def upgrade_user_from_ap_id(ap_id, async \\ true) do
 264     with %User{local: false} = user <- User.get_by_ap_id(ap_id),
 265          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
 266       data = data
 267       |> Map.put(:info, Map.merge(user.info, data[:info]))
 268
 269       {:ok, user} = User.upgrade_changeset(user, data)
 270       |> Repo.update()
 271
 272       # This could potentially take a long time, do it in the background
 273       if async do
 274         Task.start(fn ->
 275           user_upgrade_task(user)
 276         end)
 277       else
 278         user_upgrade_task(user)
 279       end
 280
 281       {:ok, user}
 282     else
 283       e -> e
 284     end
 285   end
 286
 287   def maybe_retire_websub(ap_id) do
 288     # some sanity checks
 289     if is_binary(ap_id) && (String.length(ap_id) > 8) do
 290       q = from ws in Pleroma.Web.Websub.WebsubClientSubscription,
 291         where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
 292       Repo.delete_all(q)
 293     end
 294   end
 295 end