Page MenuHomePhorge
Files F85648366

No OneTemporary
Actions

Size
8 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/lib/pleroma/web/activity_pub/importer.ex b/lib/pleroma/web/activity_pub/importer.ex
index e8adf8250..e17867ff6 100644
--- a/lib/pleroma/web/activity_pub/importer.ex
+++ b/lib/pleroma/web/activity_pub/importer.ex
@@ -1,90 +1,92 @@
# Pleroma: A lightweight social networking server
# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.ActivityPub.Importer do
alias Pleroma.User
alias Pleroma.Web.ActivityPub.Pipeline
alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Web.ActivityPub.Visibility
require Pleroma.Constants
def import_object(
%{
"type" => type,
"published" => published,
"context" => context
} = object,
%User{} = user,
opts
)
when type in Pleroma.Constants.status_types() do
fixed_object =
object
|> strip_ap_id()
|> rewrite_actor(user)
|> strip_recipients(opts)
create_data =
Utils.make_create_data(
%{
actor: user,
published: published,
object: fixed_object,
to: [],
context: context
},
%{}
)
|> Utils.lazy_put_activity_defaults()
with {:ok, activity, _meta} <-
Pipeline.common_pipeline(create_data, local: true, importing: true) do
# This is to meant to be executed in the oban queue, we only care if it succeeds,
# so don't query for and put in the object here.
{:ok, activity}
else
e -> e
end
end
+ def import_object(_, _, _), do: {:ok, nil}
+
def import_activity(%{"type" => "Create", "object" => object} = _activity, %User{} = user, opts) do
import_object(object, user, opts)
end
- def import_activity(_, _, _), do: nil
+ def import_activity(_, _, _), do: {:ok, nil}
def import_one(%{"type" => type} = object, %User{} = user, opts \\ []) do
if type in Pleroma.Constants.status_types() do
import_object(object, user, opts)
else
import_activity(object, user, opts)
end
end
defp strip_ap_id(object), do: object |> Map.drop(["id"])
defp rewrite_actor(object, user) do
object
|> Map.put("actor", user.ap_id)
end
defp strip_recipients(object, opts) do
keep_unlisted = opts[:keep_unlisted] || false
orig_is_public = Visibility.is_public?(object) and not Visibility.is_local_public?(object)
unlisted_ccs =
if keep_unlisted and orig_is_public do
[Pleroma.Constants.as_public()]
else
[]
end
object
|> Map.put("to", [])
|> Map.put("cc", [object["actor"] | unlisted_ccs])
|> Map.put("bto", [])
|> Map.put("bcc", [])
end
end
diff --git a/test/pleroma/web/activity_pub/importer_test.exs b/test/pleroma/web/activity_pub/importer_test.exs
index 9f2423612..954eb0e5f 100644
--- a/test/pleroma/web/activity_pub/importer_test.exs
+++ b/test/pleroma/web/activity_pub/importer_test.exs
@@ -1,112 +1,135 @@
# Pleroma: A lightweight social networking server
# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.ActivityPub.ImporterTest do
use Pleroma.DataCase
alias Pleroma.Activity
alias Pleroma.Web.ActivityPub.Importer
alias Pleroma.Web.ActivityPub.Transmogrifier
alias Pleroma.Web.CommonAPI
require Pleroma.Constants
import Pleroma.Factory
describe "import_one/3" do
test "it imports an activity" do
user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{status: "mew"})
{:ok, activity_for_import} = Transmogrifier.prepare_outgoing(activity.data)
importing_user = insert(:user)
assert {:ok, imported_activity} = Importer.import_one(activity_for_import, importing_user)
imported_activity = Activity.normalize(imported_activity)
assert imported_activity.id != activity.id
assert imported_activity.actor == importing_user.ap_id
assert imported_activity.object.data["actor"] == importing_user.ap_id
assert imported_activity.object.data["content"] == activity.object.data["content"]
assert imported_activity.object.data["published"] == activity.object.data["published"]
end
test "it strips all mentions" do
user = insert(:user)
user2 = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{status: "mew @#{user2.nickname}"})
assert user2.ap_id in activity.recipients
{:ok, activity_for_import} = Transmogrifier.prepare_outgoing(activity.data)
importing_user = insert(:user)
assert {:ok, imported_activity} = Importer.import_one(activity_for_import, importing_user)
imported_activity = Activity.normalize(imported_activity)
assert [importing_user.ap_id] == imported_activity.recipients
assert [] == imported_activity.object.data["to"]
assert [importing_user.ap_id] == imported_activity.object.data["cc"]
end
test "it keeps inReplyTo and context" do
user = insert(:user)
user2 = insert(:user)
{:ok, replied_to_activity} = CommonAPI.post(user2, %{status: "mew"})
{:ok, activity} =
CommonAPI.post(user, %{
status: "mew @#{user2.nickname}",
in_reply_to_id: replied_to_activity
})
assert user2.ap_id in activity.recipients
{:ok, activity_for_import} = Transmogrifier.prepare_outgoing(activity.data)
importing_user = insert(:user)
assert {:ok, imported_activity} = Importer.import_one(activity_for_import, importing_user)
imported_activity = Activity.normalize(imported_activity)
assert [importing_user.ap_id] == imported_activity.recipients
assert imported_activity.object.data["context"] == activity.object.data["context"]
assert imported_activity.object.data["inReplyTo"] == activity.object.data["inReplyTo"]
assert imported_activity.data["context"] == activity.data["context"]
end
test "it keeps public and unlisted posts unlisted with keep_unlisted option" do
verify_with_visibility = fn visibility, yn ->
user = insert(:user)
{:ok, activity} = CommonAPI.post(user, %{status: "mew", visibility: visibility})
{:ok, activity_for_import} = Transmogrifier.prepare_outgoing(activity.data)
importing_user = insert(:user)
assert {:ok, imported_activity} =
Importer.import_one(activity_for_import, importing_user, keep_unlisted: true)
imported_activity = Activity.normalize(imported_activity)
if yn do
assert [_, _] = imported_activity.recipients
else
assert [_] = imported_activity.recipients
end
assert importing_user.ap_id in imported_activity.recipients
assert Pleroma.Constants.as_public() in imported_activity.recipients == yn
assert Pleroma.Constants.as_public() in imported_activity.data["cc"] == yn
refute Pleroma.Constants.as_public() in imported_activity.data["to"]
assert Pleroma.Constants.as_public() in imported_activity.object.data["cc"] == yn
refute Pleroma.Constants.as_public() in imported_activity.object.data["to"]
end
verify_with_visibility.("public", true)
verify_with_visibility.("unlisted", true)
verify_with_visibility.("local", false)
verify_with_visibility.("private", false)
verify_with_visibility.("direct", false)
end
+
+ test "ignores on non-Create" do
+ importing_user = insert(:user)
+
+ assert {:ok, nil} =
+ Importer.import_one(%{"type" => "Announce", "object" => %{}}, importing_user)
+ end
+
+ test "ignores on non-status types" do
+ importing_user = insert(:user)
+
+ assert {:ok, nil} =
+ Importer.import_one(
+ %{"type" => "Create", "object" => %{"type" => "ChatMessage"}},
+ importing_user
+ )
+
+ assert {:ok, nil} =
+ Importer.import_one(
+ %{"type" => "Create", "object" => %{"type" => "Answer"}},
+ importing_user
+ )
+ end
end
end

File Metadata

Mime Type
text/x-diff
Expires
Fri, Aug 28, 9:12 AM (3 h, 7 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
1736327
Default Alt Text
(8 KB)

Event Timeline