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