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.Web.ActivityPub.ActivityPub
   9
  10   @doc """
  11   Modifies an incoming AP object (mastodon format) to our internal format.
  12   """
  13   def fix_object(object) do
  14     object
  15     |> Map.put("actor", object["attributedTo"])
  16     |> fix_attachments
  17     |> fix_context
  18   end
  19
  20   def fix_context(object) do
  21     object
  22     |> Map.put("context", object["conversation"])
  23   end
  24
  25   def fix_attachments(object) do
  26     attachments = (object["attachment"] || [])
  27     |> Enum.map(fn (data) ->
  28       url = [%{"type" => "Link", "mediaType" => data["mediaType"], "href" => data["url"]}]
  29       Map.put(data, "url", url)
  30     end)
  31
  32     object
  33     |> Map.put("attachment", attachments)
  34   end
  35
  36   # TODO: validate those with a Ecto scheme
  37   # - tags
  38   # - emoji
  39   def handle_incoming(%{"type" => "Create", "object" => %{"type" => "Note"} = object} = data) do
  40     with nil <- Activity.get_create_activity_by_object_ap_id(object["id"]),
  41          %User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
  42       object = fix_object(data["object"])
  43       params = %{
  44         to: data["to"],
  45         object: object,
  46         actor: user,
  47         context: data["object"]["conversation"],
  48         local: false,
  49         published: data["published"],
  50         additional: Map.take(data, [
  51               "cc",
  52               "id"
  53             ])
  54       }
  55
  56       ActivityPub.create(params)
  57     else
  58       %Activity{} = activity -> {:ok, activity}
  59       _e -> :error
  60     end
  61   end
  62
  63   def handle_incoming(%{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data) do
  64     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
  65          %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
  66          {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
  67       ActivityPub.accept(%{to: [follower.ap_id], actor: followed.ap_id, object: data, local: true})
  68       User.follow(follower, followed)
  69       {:ok, activity}
  70     else
  71       _e -> :error
  72     end
  73   end
  74
  75   def handle_incoming(%{"type" => "Like", "object" => object_id, "actor" => actor, "id" => id} = data) do
  76     with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
  77          %Object{} = object <- Object.get_by_ap_id(object_id),
  78          {:ok, activity, object} <- ActivityPub.like(actor, object, id, false) do
  79       {:ok, activity}
  80     else
  81       _e -> :error
  82     end
  83   end
  84
  85   def handle_incoming(%{"type" => "Announce", "object" => object_id, "actor" => actor, "id" => id} = data) do
  86     with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
  87          {:ok, object} <- get_obj_helper(object_id) || ActivityPub.fetch_object_from_id(object_id),
  88          {:ok, activity, object} <- ActivityPub.announce(actor, object, id, false) do
  89       {:ok, activity}
  90     else
  91       _e -> :error
  92     end
  93   end
  94
  95   # TODO
  96   # Accept
  97   # Undo
  98
  99   def handle_incoming(_), do: :error
 100
 101   def get_obj_helper(id) do
 102     if object = Object.get_by_ap_id(id), do: {:ok, object}, else: nil
 103   end
 104
 105   @doc
 106   """
 107   internal -> Mastodon
 108   """
 109   def prepare_outgoing(%{"type" => "Create", "object" => %{"type" => "Note"} = object} = data) do
 110     object = object
 111     |> set_sensitive
 112     |> add_hashtags
 113     |> add_mention_tags
 114     |> add_attributed_to
 115     |> prepare_attachments
 116     |> set_conversation
 117
 118     data = data
 119     |> Map.put("object", object)
 120     |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 121
 122     {:ok, data}
 123   end
 124
 125   def prepare_outgoing(%{"type" => type} = data) do
 126     data = data
 127     |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 128
 129     {:ok, data}
 130   end
 131
 132   def add_hashtags(object) do
 133     tags = (object["tag"] || [])
 134     |> Enum.map fn (tag) -> %{"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}", "name" => "##{tag}", "type" => "Hashtag"} end
 135
 136     object
 137     |> Map.put("tag", tags)
 138   end
 139
 140   def add_mention_tags(object) do
 141     recipients = object["to"] ++ (object["cc"] || [])
 142     mentions = recipients
 143     |> Enum.map(fn (ap_id) -> User.get_cached_by_ap_id(ap_id) end)
 144     |> Enum.filter(&(&1))
 145     |> Enum.map(fn(user) -> %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"} end)
 146
 147     tags = object["tag"] || []
 148
 149     object
 150     |> Map.put("tag", tags ++ mentions)
 151   end
 152
 153   def set_conversation(object) do
 154     Map.put(object, "conversation", object["context"])
 155   end
 156
 157   def set_sensitive(object) do
 158     tags = object["tag"] || []
 159     Map.put(object, "sensitive", "nsfw" in tags)
 160   end
 161
 162   def add_attributed_to(object) do
 163     attributedTo = object["attributedTo"] || object["actor"]
 164
 165     object
 166     |> Map.put("attributedTo", attributedTo)
 167   end
 168
 169   def prepare_attachments(object) do
 170     attachments = (object["attachment"] || [])
 171     |> Enum.map(fn (data) ->
 172       [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
 173       %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
 174     end)
 175
 176     object
 177     |> Map.put("attachment", attachments)
 178   end
 179 end