ActivityPubController: Handle inbox data.

[akkoma] / lib / pleroma / web / activity_pub / activity_pub.ex

diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
index 5b02fc2c6b71e952bd085b8e90342656eed4f0e5..a7b2988b9afe506c352e107c304c852e8a06e836 100644 (file)
--- a/lib/pleroma/web/activity_pub/activity_pub.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
@@ -1,16 +1,22 @@
 defmodule Pleroma.Web.ActivityPub.ActivityPub do
-  alias Pleroma.{Activity, Repo, Object, Upload, User, Web, Notification}
-  alias Ecto.{Changeset, UUID}
+  alias Pleroma.{Activity, Repo, Object, Upload, User, Notification}
   import Ecto.Query
   import Pleroma.Web.ActivityPub.Utils
   require Logger
 
+  @httpoison Application.get_env(:pleroma, :httpoison)
+
+  def get_recipients(data) do
+    (data["to"] || []) ++ (data["cc"] || [])
+  end
+
   def insert(map, local \\ true) when is_map(map) do
     with nil <- Activity.get_by_ap_id(map["id"]),
          map <- lazy_put_activity_defaults(map),
          :ok <- insert_full_object(map) do
-      {:ok, activity} = Repo.insert(%Activity{data: map, local: local, actor: map["actor"]})
+      {:ok, activity} = Repo.insert(%Activity{data: map, local: local, actor: map["actor"], recipients: get_recipients(map)})
       Notification.create_notifications(activity)
+      stream_out(activity)
       {:ok, activity}
     else
       %Activity{} = activity -> {:ok, activity}
@@ -18,19 +24,32 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
     end
   end
 
-  def create(to, actor, context, object, additional \\ %{}, published \\ nil, local \\ true) do
+  def stream_out(activity) do
+    if activity.data["type"] in ["Create", "Announce"] do
+      Pleroma.Web.Streamer.stream("user", activity)
+      if Enum.member?(activity.data["to"], "https://www.w3.org/ns/activitystreams#Public") do
+        Pleroma.Web.Streamer.stream("public", activity)
+        if activity.local do
+          Pleroma.Web.Streamer.stream("public:local", activity)
+        end
+      end
+    end
+  end
+
+  def create(%{to: to, actor: actor, context: context, object: object} = params) do
+    additional = params[:additional] || %{}
+    local = !(params[:local] == false) # only accept false as false value
+    published = params[:published]
+
     with create_data <- make_create_data(%{to: to, actor: actor, published: published, context: context, object: object}, additional),
          {:ok, activity} <- insert(create_data, local),
          :ok <- maybe_federate(activity) do
-      if activity.data["type"] == "Create" and Enum.member?(activity.data["to"], "https://www.w3.org/ns/activitystreams#Public") do
-        Pleroma.Web.Streamer.stream("public", activity)
-      end
       {:ok, activity}
     end
   end
 
   # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
-  def like(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object, activity_id \\ nil, local \\ true) do
+  def like(%User{ap_id: ap_id} = user, %Object{data: %{"id" => _}} = object, activity_id \\ nil, local \\ true) do
     with nil <- get_existing_like(ap_id, object),
          like_data <- make_like_data(user, object, activity_id),
          {:ok, activity} <- insert(like_data, local),
@@ -52,7 +71,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
     end
   end
 
-  def announce(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object, activity_id \\ nil, local \\ true) do
+  def announce(%User{ap_id: _} = user, %Object{data: %{"id" => _}} = object, activity_id \\ nil, local \\ true) do
     with announce_data <- make_announce_data(user, object, activity_id),
          {:ok, activity} <- insert(announce_data, local),
          {:ok, object} <- add_announce_to_object(activity, object),
@@ -159,7 +178,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
   end
   defp restrict_favorited_by(query, _), do: query
 
-  defp restrict_media(query, %{"only_media" => true}) do
+  defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
     from activity in query,
       where: fragment("not (? #> '{\"object\",\"attachment\"}' = ?)", activity.data, ^[])
   end
@@ -206,4 +225,42 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
     data = Upload.store(file)
     Repo.insert(%Object{data: data})
   end
+
+  def make_user_from_ap_id(ap_id) do
+    with {:ok, %{status_code: 200, body: body}} <- @httpoison.get(ap_id, ["Accept": "application/activity+json"]),
+    {:ok, data} <- Poison.decode(body)
+      do
+      user_data = %{
+        ap_id: data["id"],
+        info: %{
+          "ap_enabled" => true,
+          "source_data" => data
+        },
+        nickname: "#{data["preferredUsername"]}@#{URI.parse(ap_id).host}",
+        name: data["name"]
+      }
+
+      User.insert_or_update_user(user_data)
+    end
+  end
+
+  # TODO: Extract to own module, align as close to Mastodon format as possible.
+  def sanitize_outgoing_activity_data(data) do
+    data
+    |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
+  end
+
+  def publish(actor, activity) do
+    remote_users = Pleroma.Web.Salmon.remote_users(activity)
+    data = sanitize_outgoing_activity_data(activity.data)
+    Enum.each remote_users, fn(user) ->
+      if user.info["ap_enabled"] do
+        inbox = user.info["source_data"]["inbox"]
+        Logger.info("Federating #{activity.data["id"]} to #{inbox}")
+        host = URI.parse(inbox).host
+        signature = Pleroma.Web.HTTPSignatures.sign(actor, %{host: host})
+        @httpoison.post(inbox, Poison.encode!(data), [{"Content-Type", "application/activity+json"}, {"signature", signature}])
+      end
+    end
+  end
 end