Add local-only statuses

This commit is contained in:
Egor Kislitsyn 2020-10-02 21:00:50 +04:00
parent b48724afcd
commit 4f79bbbc31
No known key found for this signature in database
GPG key ID: 1B49CB15B71E7805
16 changed files with 332 additions and 163 deletions

View file

@ -28,6 +28,7 @@ Has these additional fields under the `pleroma` object:
- `thread_muted`: true if the thread the post belongs to is muted - `thread_muted`: true if the thread the post belongs to is muted
- `emoji_reactions`: A list with emoji / reaction maps. The format is `{name: "☕", count: 1, me: true}`. Contains no information about the reacting users, for that use the `/statuses/:id/reactions` endpoint. - `emoji_reactions`: A list with emoji / reaction maps. The format is `{name: "☕", count: 1, me: true}`. Contains no information about the reacting users, for that use the `/statuses/:id/reactions` endpoint.
- `parent_visible`: If the parent of this post is visible to the user or not. - `parent_visible`: If the parent of this post is visible to the user or not.
- `local_only`: true for local-only, non-federated posts.
## Media Attachments ## Media Attachments
@ -154,6 +155,7 @@ Additional parameters can be added to the JSON body/Form data:
- `visibility`: string, besides standard MastoAPI values (`direct`, `private`, `unlisted` or `public`) it can be used to address a List by setting it to `list:LIST_ID`. - `visibility`: string, besides standard MastoAPI values (`direct`, `private`, `unlisted` or `public`) it can be used to address a List by setting it to `list:LIST_ID`.
- `expires_in`: The number of seconds the posted activity should expire in. When a posted activity expires it will be deleted from the server, and a delete request for it will be federated. This needs to be longer than an hour. - `expires_in`: The number of seconds the posted activity should expire in. When a posted activity expires it will be deleted from the server, and a delete request for it will be federated. This needs to be longer than an hour.
- `in_reply_to_conversation_id`: Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`. - `in_reply_to_conversation_id`: Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`.
- `local_only`: boolean, if set to `true` the post won't be federated.
## GET `/api/v1/statuses` ## GET `/api/v1/statuses`

View file

@ -18,6 +18,8 @@ defmodule Pleroma.Activity do
import Ecto.Changeset import Ecto.Changeset
import Ecto.Query import Ecto.Query
require Pleroma.Constants
@type t :: %__MODULE__{} @type t :: %__MODULE__{}
@type actor :: String.t() @type actor :: String.t()
@ -343,4 +345,12 @@ defmodule Pleroma.Activity do
actor = user_actor(activity) actor = user_actor(activity)
activity.id in actor.pinned_activities activity.id in actor.pinned_activities
end end
def local_only?(activity) do
recipients = Enum.concat(activity.data["to"], Map.get(activity.data, "cc", []))
public = Pleroma.Constants.as_public()
local = Pleroma.Web.base_url() <> "/#Public"
Enum.member?(recipients, local) and not Enum.member?(recipients, public)
end
end end

View file

@ -222,6 +222,9 @@ defmodule Pleroma.Web.ActivityPub.Builder do
actor.ap_id == Relay.ap_id() -> actor.ap_id == Relay.ap_id() ->
[actor.follower_address] [actor.follower_address]
public? and Pleroma.Activity.local_only?(object) ->
[actor.follower_address, object.data["actor"], Pleroma.Web.base_url() <> "/#Public"]
public? -> public? ->
[actor.follower_address, object.data["actor"], Pleroma.Constants.as_public()] [actor.follower_address, object.data["actor"], Pleroma.Constants.as_public()]

View file

@ -67,7 +67,12 @@ defmodule Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator do
%Object{} = object <- Object.get_cached_by_ap_id(object), %Object{} = object <- Object.get_cached_by_ap_id(object),
false <- Visibility.is_public?(object) do false <- Visibility.is_public?(object) do
same_actor = object.data["actor"] == actor.ap_id same_actor = object.data["actor"] == actor.ap_id
is_public = Pleroma.Constants.as_public() in (get_field(cng, :to) ++ get_field(cng, :cc)) recipients = get_field(cng, :to) ++ get_field(cng, :cc)
local_public = Pleroma.Web.base_url() <> "/#Public"
is_public =
Enum.member?(recipients, Pleroma.Constants.as_public()) or
Enum.member?(recipients, local_public)
cond do cond do
same_actor && is_public -> same_actor && is_public ->

View file

@ -55,7 +55,7 @@ defmodule Pleroma.Web.ActivityPub.Pipeline do
with {:ok, local} <- Keyword.fetch(meta, :local) do with {:ok, local} <- Keyword.fetch(meta, :local) do
do_not_federate = meta[:do_not_federate] || !Config.get([:instance, :federating]) do_not_federate = meta[:do_not_federate] || !Config.get([:instance, :federating])
if !do_not_federate && local do if !do_not_federate and local and not Activity.local_only?(activity) do
activity = activity =
if object = Keyword.get(meta, :object_data) do if object = Keyword.get(meta, :object_data) do
%{activity | data: Map.put(activity.data, "object", object)} %{activity | data: Map.put(activity.data, "object", object)}

View file

@ -175,7 +175,8 @@ defmodule Pleroma.Web.ActivityPub.Utils do
outgoing_blocks = Config.get([:activitypub, :outgoing_blocks]) outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
with true <- Config.get!([:instance, :federating]), with true <- Config.get!([:instance, :federating]),
true <- type != "Block" || outgoing_blocks do true <- type != "Block" || outgoing_blocks,
false <- Activity.local_only?(activity) do
Pleroma.Web.Federator.publish(activity) Pleroma.Web.Federator.publish(activity)
end end

View file

@ -17,7 +17,11 @@ defmodule Pleroma.Web.ActivityPub.Visibility do
def is_public?(%Activity{data: %{"type" => "Move"}}), do: true def is_public?(%Activity{data: %{"type" => "Move"}}), do: true
def is_public?(%Activity{data: data}), do: is_public?(data) def is_public?(%Activity{data: data}), do: is_public?(data)
def is_public?(%{"directMessage" => true}), do: false def is_public?(%{"directMessage" => true}), do: false
def is_public?(data), do: Utils.label_in_message?(Pleroma.Constants.as_public(), data)
def is_public?(data) do
Utils.label_in_message?(Pleroma.Constants.as_public(), data) or
Utils.label_in_message?(Pleroma.Web.base_url() <> "/#Public", data)
end
def is_private?(activity) do def is_private?(activity) do
with false <- is_public?(activity), with false <- is_public?(activity),

View file

@ -475,6 +475,10 @@ defmodule Pleroma.Web.ApiSpec.StatusOperation do
type: :string, type: :string,
description: description:
"Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`." "Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`."
},
local_only: %Schema{
type: :boolean,
description: "Post the status as local only"
} }
}, },
example: %{ example: %{

View file

@ -15,6 +15,7 @@ defmodule Pleroma.Web.CommonAPI do
alias Pleroma.Web.ActivityPub.Pipeline alias Pleroma.Web.ActivityPub.Pipeline
alias Pleroma.Web.ActivityPub.Utils alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Web.ActivityPub.Visibility alias Pleroma.Web.ActivityPub.Visibility
alias Pleroma.Web.CommonAPI.ActivityDraft
import Pleroma.Web.Gettext import Pleroma.Web.Gettext
import Pleroma.Web.CommonAPI.Utils import Pleroma.Web.CommonAPI.Utils
@ -398,31 +399,13 @@ defmodule Pleroma.Web.CommonAPI do
end end
def listen(user, data) do def listen(user, data) do
visibility = Map.get(data, :visibility, "public") with {:ok, draft} <- ActivityDraft.listen(user, data) do
ActivityPub.listen(draft.changes)
with {to, cc} <- get_to_and_cc(user, [], nil, visibility, nil),
listen_data <-
data
|> Map.take([:album, :artist, :title, :length])
|> Map.new(fn {key, value} -> {to_string(key), value} end)
|> Map.put("type", "Audio")
|> Map.put("to", to)
|> Map.put("cc", cc)
|> Map.put("actor", user.ap_id),
{:ok, activity} <-
ActivityPub.listen(%{
actor: user,
to: to,
object: listen_data,
context: Utils.generate_context_id(),
additional: %{"cc" => cc}
}) do
{:ok, activity}
end end
end end
def post(user, %{status: _} = data) do def post(user, %{status: _} = data) do
with {:ok, draft} <- Pleroma.Web.CommonAPI.ActivityDraft.create(user, data) do with {:ok, draft} <- ActivityDraft.create(user, data) do
ActivityPub.create(draft.changes, draft.preview?) ActivityPub.create(draft.changes, draft.preview?)
end end
end end

View file

@ -22,7 +22,7 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
in_reply_to_conversation: nil, in_reply_to_conversation: nil,
visibility: nil, visibility: nil,
expires_at: nil, expires_at: nil,
poll: nil, extra: nil,
emoji: %{}, emoji: %{},
content_html: nil, content_html: nil,
mentions: [], mentions: [],
@ -35,9 +35,14 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
preview?: false, preview?: false,
changes: %{} changes: %{}
def create(user, params) do def new(user, params) do
%__MODULE__{user: user} %__MODULE__{user: user}
|> put_params(params) |> put_params(params)
end
def create(user, params) do
user
|> new(params)
|> status() |> status()
|> summary() |> summary()
|> with_valid(&attachments/1) |> with_valid(&attachments/1)
@ -57,6 +62,30 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
|> validate() |> validate()
end end
def listen(user, params) do
user
|> new(params)
|> visibility()
|> to_and_cc()
|> context()
|> listen_object()
|> with_valid(&changes/1)
|> validate()
end
defp listen_object(draft) do
object =
draft.params
|> Map.take([:album, :artist, :title, :length])
|> Map.new(fn {key, value} -> {to_string(key), value} end)
|> Map.put("type", "Audio")
|> Map.put("to", draft.to)
|> Map.put("cc", draft.cc)
|> Map.put("actor", draft.user.ap_id)
%__MODULE__{draft | object: object}
end
defp put_params(draft, params) do defp put_params(draft, params) do
params = Map.put_new(params, :in_reply_to_status_id, params[:in_reply_to_id]) params = Map.put_new(params, :in_reply_to_status_id, params[:in_reply_to_id])
%__MODULE__{draft | params: params} %__MODULE__{draft | params: params}
@ -121,7 +150,7 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
defp poll(draft) do defp poll(draft) do
case Utils.make_poll_data(draft.params) do case Utils.make_poll_data(draft.params) do
{:ok, {poll, poll_emoji}} -> {:ok, {poll, poll_emoji}} ->
%__MODULE__{draft | poll: poll, emoji: Map.merge(draft.emoji, poll_emoji)} %__MODULE__{draft | extra: poll, emoji: Map.merge(draft.emoji, poll_emoji)}
{:error, message} -> {:error, message} ->
add_error(draft, message) add_error(draft, message)
@ -129,32 +158,18 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
end end
defp content(draft) do defp content(draft) do
{content_html, mentions, tags} = {content_html, mentioned_users, tags} = Utils.make_content_html(draft)
Utils.make_content_html(
draft.status, mentions =
draft.attachments, mentioned_users
draft.params, |> Enum.map(fn {_, mentioned_user} -> mentioned_user.ap_id end)
draft.visibility |> Utils.get_addressed_users(draft.params[:to])
)
%__MODULE__{draft | content_html: content_html, mentions: mentions, tags: tags} %__MODULE__{draft | content_html: content_html, mentions: mentions, tags: tags}
end end
defp to_and_cc(draft) do defp to_and_cc(draft) do
addressed_users = {to, cc} = Utils.get_to_and_cc(draft)
draft.mentions
|> Enum.map(fn {_, mentioned_user} -> mentioned_user.ap_id end)
|> Utils.get_addressed_users(draft.params[:to])
{to, cc} =
Utils.get_to_and_cc(
draft.user,
addressed_users,
draft.in_reply_to,
draft.visibility,
draft.in_reply_to_conversation
)
%__MODULE__{draft | to: to, cc: cc} %__MODULE__{draft | to: to, cc: cc}
end end
@ -172,19 +187,7 @@ defmodule Pleroma.Web.CommonAPI.ActivityDraft do
emoji = Map.merge(Pleroma.Emoji.Formatter.get_emoji_map(draft.full_payload), draft.emoji) emoji = Map.merge(Pleroma.Emoji.Formatter.get_emoji_map(draft.full_payload), draft.emoji)
object = object =
Utils.make_note_data( Utils.make_note_data(draft)
draft.user.ap_id,
draft.to,
draft.context,
draft.content_html,
draft.attachments,
draft.in_reply_to,
draft.tags,
draft.summary,
draft.cc,
draft.sensitive,
draft.poll
)
|> Map.put("emoji", emoji) |> Map.put("emoji", emoji)
|> Map.put("source", draft.status) |> Map.put("source", draft.status)

View file

@ -16,6 +16,7 @@ defmodule Pleroma.Web.CommonAPI.Utils do
alias Pleroma.User alias Pleroma.User
alias Pleroma.Web.ActivityPub.Utils alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Web.ActivityPub.Visibility alias Pleroma.Web.ActivityPub.Visibility
alias Pleroma.Web.CommonAPI.ActivityDraft
alias Pleroma.Web.MediaProxy alias Pleroma.Web.MediaProxy
alias Pleroma.Web.Plugs.AuthenticationPlug alias Pleroma.Web.Plugs.AuthenticationPlug
@ -50,67 +51,60 @@ defmodule Pleroma.Web.CommonAPI.Utils do
{_, descs} = Jason.decode(descs_str) {_, descs} = Jason.decode(descs_str)
Enum.map(ids, fn media_id -> Enum.map(ids, fn media_id ->
case Repo.get(Object, media_id) do with %Object{data: data} <- Repo.get(Object, media_id) do
%Object{data: data} -> Map.put(data, "name", descs[media_id])
Map.put(data, "name", descs[media_id])
_ ->
nil
end end
end) end)
|> Enum.reject(&is_nil/1) |> Enum.reject(&is_nil/1)
end end
@spec get_to_and_cc( @spec get_to_and_cc(ActivityDraft.t()) :: {list(String.t()), list(String.t())}
User.t(),
list(String.t()),
Activity.t() | nil,
String.t(),
Participation.t() | nil
) :: {list(String.t()), list(String.t())}
def get_to_and_cc(_, _, _, _, %Participation{} = participation) do def get_to_and_cc(%{in_reply_to_conversation: %Participation{} = participation}) do
participation = Repo.preload(participation, :recipients) participation = Repo.preload(participation, :recipients)
{Enum.map(participation.recipients, & &1.ap_id), []} {Enum.map(participation.recipients, & &1.ap_id), []}
end end
def get_to_and_cc(user, mentioned_users, inReplyTo, "public", _) do def get_to_and_cc(%{visibility: "public"} = draft) do
to = [Pleroma.Constants.as_public() | mentioned_users] to = [public_uri(draft) | draft.mentions]
cc = [user.follower_address] cc = [draft.user.follower_address]
if inReplyTo do if draft.in_reply_to do
{Enum.uniq([inReplyTo.data["actor"] | to]), cc} {Enum.uniq([draft.in_reply_to.data["actor"] | to]), cc}
else else
{to, cc} {to, cc}
end end
end end
def get_to_and_cc(user, mentioned_users, inReplyTo, "unlisted", _) do def get_to_and_cc(%{visibility: "unlisted"} = draft) do
to = [user.follower_address | mentioned_users] to = [draft.user.follower_address | draft.mentions]
cc = [Pleroma.Constants.as_public()] cc = [public_uri(draft)]
if inReplyTo do if draft.in_reply_to do
{Enum.uniq([inReplyTo.data["actor"] | to]), cc} {Enum.uniq([draft.in_reply_to.data["actor"] | to]), cc}
else else
{to, cc} {to, cc}
end end
end end
def get_to_and_cc(user, mentioned_users, inReplyTo, "private", _) do def get_to_and_cc(%{visibility: "private"} = draft) do
{to, cc} = get_to_and_cc(user, mentioned_users, inReplyTo, "direct", nil) {to, cc} = get_to_and_cc(struct(draft, visibility: "direct"))
{[user.follower_address | to], cc} {[draft.user.follower_address | to], cc}
end end
def get_to_and_cc(_user, mentioned_users, inReplyTo, "direct", _) do def get_to_and_cc(%{visibility: "direct"} = draft) do
# If the OP is a DM already, add the implicit actor. # If the OP is a DM already, add the implicit actor.
if inReplyTo && Visibility.is_direct?(inReplyTo) do if draft.in_reply_to && Visibility.is_direct?(draft.in_reply_to) do
{Enum.uniq([inReplyTo.data["actor"] | mentioned_users]), []} {Enum.uniq([draft.in_reply_to.data["actor"] | draft.mentions]), []}
else else
{mentioned_users, []} {draft.mentions, []}
end end
end end
def get_to_and_cc(_user, mentions, _inReplyTo, {:list, _}, _), do: {mentions, []} def get_to_and_cc(%{visibility: {:list, _}, mentions: mentions}), do: {mentions, []}
defp public_uri(%{params: %{local_only: true}}), do: Pleroma.Web.base_url() <> "/#Public"
defp public_uri(_), do: Pleroma.Constants.as_public()
def get_addressed_users(_, to) when is_list(to) do def get_addressed_users(_, to) when is_list(to) do
User.get_ap_ids_by_nicknames(to) User.get_ap_ids_by_nicknames(to)
@ -203,30 +197,25 @@ defmodule Pleroma.Web.CommonAPI.Utils do
end end
end end
def make_content_html( def make_content_html(%ActivityDraft{} = draft) do
status,
attachments,
data,
visibility
) do
attachment_links = attachment_links =
data draft.params
|> Map.get("attachment_links", Config.get([:instance, :attachment_links])) |> Map.get("attachment_links", Config.get([:instance, :attachment_links]))
|> truthy_param?() |> truthy_param?()
content_type = get_content_type(data[:content_type]) content_type = get_content_type(draft.params[:content_type])
options = options =
if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do if draft.visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
[safe_mention: true] [safe_mention: true]
else else
[] []
end end
status draft.status
|> format_input(content_type, options) |> format_input(content_type, options)
|> maybe_add_attachments(attachments, attachment_links) |> maybe_add_attachments(draft.attachments, attachment_links)
|> maybe_add_nsfw_tag(data) |> maybe_add_nsfw_tag(draft.params)
end end
defp get_content_type(content_type) do defp get_content_type(content_type) do
@ -317,33 +306,21 @@ defmodule Pleroma.Web.CommonAPI.Utils do
|> Formatter.html_escape("text/html") |> Formatter.html_escape("text/html")
end end
def make_note_data( def make_note_data(%ActivityDraft{} = draft) do
actor,
to,
context,
content_html,
attachments,
in_reply_to,
tags,
summary \\ nil,
cc \\ [],
sensitive \\ false,
extra_params \\ %{}
) do
%{ %{
"type" => "Note", "type" => "Note",
"to" => to, "to" => draft.to,
"cc" => cc, "cc" => draft.cc,
"content" => content_html, "content" => draft.content_html,
"summary" => summary, "summary" => draft.summary,
"sensitive" => truthy_param?(sensitive), "sensitive" => draft.sensitive,
"context" => context, "context" => draft.context,
"attachment" => attachments, "attachment" => draft.attachments,
"actor" => actor, "actor" => draft.user.ap_id,
"tag" => Keyword.values(tags) |> Enum.uniq() "tag" => Keyword.values(draft.tags) |> Enum.uniq()
} }
|> add_in_reply_to(in_reply_to) |> add_in_reply_to(draft.in_reply_to)
|> Map.merge(extra_params) |> Map.merge(draft.extra)
end end
defp add_in_reply_to(object, nil), do: object defp add_in_reply_to(object, nil), do: object

View file

@ -368,7 +368,8 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
direct_conversation_id: direct_conversation_id, direct_conversation_id: direct_conversation_id,
thread_muted: thread_muted?, thread_muted: thread_muted?,
emoji_reactions: emoji_reactions, emoji_reactions: emoji_reactions,
parent_visible: visible_for_user?(reply_to, opts[:for]) parent_visible: visible_for_user?(reply_to, opts[:for]),
local_only: Activity.local_only?(activity)
} }
} }
end end

View file

@ -6,6 +6,7 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
alias Pleroma.Builders.UserBuilder alias Pleroma.Builders.UserBuilder
alias Pleroma.Object alias Pleroma.Object
alias Pleroma.Web.CommonAPI alias Pleroma.Web.CommonAPI
alias Pleroma.Web.CommonAPI.ActivityDraft
alias Pleroma.Web.CommonAPI.Utils alias Pleroma.Web.CommonAPI.Utils
use Pleroma.DataCase use Pleroma.DataCase
@ -235,9 +236,9 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
test "for public posts, not a reply" do test "for public posts, not a reply" do
user = insert(:user) user = insert(:user)
mentioned_user = insert(:user) mentioned_user = insert(:user)
mentions = [mentioned_user.ap_id] draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "public"}
{to, cc} = Utils.get_to_and_cc(user, mentions, nil, "public", nil) {to, cc} = Utils.get_to_and_cc(draft)
assert length(to) == 2 assert length(to) == 2
assert length(cc) == 1 assert length(cc) == 1
@ -252,9 +253,15 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
mentioned_user = insert(:user) mentioned_user = insert(:user)
third_user = insert(:user) third_user = insert(:user)
{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"}) {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
mentions = [mentioned_user.ap_id]
{to, cc} = Utils.get_to_and_cc(user, mentions, activity, "public", nil) draft = %ActivityDraft{
user: user,
mentions: [mentioned_user.ap_id],
visibility: "public",
in_reply_to: activity
}
{to, cc} = Utils.get_to_and_cc(draft)
assert length(to) == 3 assert length(to) == 3
assert length(cc) == 1 assert length(cc) == 1
@ -268,9 +275,9 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
test "for unlisted posts, not a reply" do test "for unlisted posts, not a reply" do
user = insert(:user) user = insert(:user)
mentioned_user = insert(:user) mentioned_user = insert(:user)
mentions = [mentioned_user.ap_id] draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "unlisted"}
{to, cc} = Utils.get_to_and_cc(user, mentions, nil, "unlisted", nil) {to, cc} = Utils.get_to_and_cc(draft)
assert length(to) == 2 assert length(to) == 2
assert length(cc) == 1 assert length(cc) == 1
@ -285,9 +292,15 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
mentioned_user = insert(:user) mentioned_user = insert(:user)
third_user = insert(:user) third_user = insert(:user)
{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"}) {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
mentions = [mentioned_user.ap_id]
{to, cc} = Utils.get_to_and_cc(user, mentions, activity, "unlisted", nil) draft = %ActivityDraft{
user: user,
mentions: [mentioned_user.ap_id],
visibility: "unlisted",
in_reply_to: activity
}
{to, cc} = Utils.get_to_and_cc(draft)
assert length(to) == 3 assert length(to) == 3
assert length(cc) == 1 assert length(cc) == 1
@ -301,9 +314,9 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
test "for private posts, not a reply" do test "for private posts, not a reply" do
user = insert(:user) user = insert(:user)
mentioned_user = insert(:user) mentioned_user = insert(:user)
mentions = [mentioned_user.ap_id] draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "private"}
{to, cc} = Utils.get_to_and_cc(user, mentions, nil, "private", nil) {to, cc} = Utils.get_to_and_cc(draft)
assert length(to) == 2 assert length(to) == 2
assert Enum.empty?(cc) assert Enum.empty?(cc)
@ -316,9 +329,15 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
mentioned_user = insert(:user) mentioned_user = insert(:user)
third_user = insert(:user) third_user = insert(:user)
{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"}) {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
mentions = [mentioned_user.ap_id]
{to, cc} = Utils.get_to_and_cc(user, mentions, activity, "private", nil) draft = %ActivityDraft{
user: user,
mentions: [mentioned_user.ap_id],
visibility: "private",
in_reply_to: activity
}
{to, cc} = Utils.get_to_and_cc(draft)
assert length(to) == 2 assert length(to) == 2
assert Enum.empty?(cc) assert Enum.empty?(cc)
@ -330,9 +349,9 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
test "for direct posts, not a reply" do test "for direct posts, not a reply" do
user = insert(:user) user = insert(:user)
mentioned_user = insert(:user) mentioned_user = insert(:user)
mentions = [mentioned_user.ap_id] draft = %ActivityDraft{user: user, mentions: [mentioned_user.ap_id], visibility: "direct"}
{to, cc} = Utils.get_to_and_cc(user, mentions, nil, "direct", nil) {to, cc} = Utils.get_to_and_cc(draft)
assert length(to) == 1 assert length(to) == 1
assert Enum.empty?(cc) assert Enum.empty?(cc)
@ -345,9 +364,15 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
mentioned_user = insert(:user) mentioned_user = insert(:user)
third_user = insert(:user) third_user = insert(:user)
{:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"}) {:ok, activity} = CommonAPI.post(third_user, %{status: "uguu"})
mentions = [mentioned_user.ap_id]
{to, cc} = Utils.get_to_and_cc(user, mentions, activity, "direct", nil) draft = %ActivityDraft{
user: user,
mentions: [mentioned_user.ap_id],
visibility: "direct",
in_reply_to: activity
}
{to, cc} = Utils.get_to_and_cc(draft)
assert length(to) == 1 assert length(to) == 1
assert Enum.empty?(cc) assert Enum.empty?(cc)
@ -356,7 +381,14 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
{:ok, direct_activity} = CommonAPI.post(third_user, %{status: "uguu", visibility: "direct"}) {:ok, direct_activity} = CommonAPI.post(third_user, %{status: "uguu", visibility: "direct"})
{to, cc} = Utils.get_to_and_cc(user, mentions, direct_activity, "direct", nil) draft = %ActivityDraft{
user: user,
mentions: [mentioned_user.ap_id],
visibility: "direct",
in_reply_to: direct_activity
}
{to, cc} = Utils.get_to_and_cc(draft)
assert length(to) == 2 assert length(to) == 2
assert Enum.empty?(cc) assert Enum.empty?(cc)
@ -532,26 +564,26 @@ defmodule Pleroma.Web.CommonAPI.UtilsTest do
end end
end end
describe "make_note_data/11" do describe "make_note_data/1" do
test "returns note data" do test "returns note data" do
user = insert(:user) user = insert(:user)
note = insert(:note) note = insert(:note)
user2 = insert(:user) user2 = insert(:user)
user3 = insert(:user) user3 = insert(:user)
assert Utils.make_note_data( draft = %ActivityDraft{
user.ap_id, user: user,
[user2.ap_id], to: [user2.ap_id],
"2hu", context: "2hu",
"<h1>This is :moominmamma: note</h1>", content_html: "<h1>This is :moominmamma: note</h1>",
[], in_reply_to: note.id,
note.id, tags: [name: "jimm"],
[name: "jimm"], summary: "test summary",
"test summary", cc: [user3.ap_id],
[user3.ap_id], extra: %{"custom_tag" => "test"}
false, }
%{"custom_tag" => "test"}
) == %{ assert Utils.make_note_data(draft) == %{
"actor" => user.ap_id, "actor" => user.ap_id,
"attachment" => [], "attachment" => [],
"cc" => [user3.ap_id], "cc" => [user3.ap_id],

View file

@ -1241,4 +1241,128 @@ defmodule Pleroma.Web.CommonAPITest do
} = CommonAPI.get_user("") } = CommonAPI.get_user("")
end end
end end
describe "with `local_only` enabled" do
setup do: clear_config([:instance, :federating], true)
test "post" do
user = insert(:user)
with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU", local_only: true})
assert Activity.local_only?(activity)
assert_not_called(Pleroma.Web.Federator.publish(activity))
end
end
test "delete" do
user = insert(:user)
{:ok, %Activity{id: activity_id}} =
CommonAPI.post(user, %{status: "#2hu #2HU", local_only: true})
with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
assert {:ok, %Activity{data: %{"deleted_activity_id" => ^activity_id}} = activity} =
CommonAPI.delete(activity_id, user)
assert Activity.local_only?(activity)
assert_not_called(Pleroma.Web.Federator.publish(activity))
end
end
test "repeat" do
user = insert(:user)
other_user = insert(:user)
{:ok, %Activity{id: activity_id}} =
CommonAPI.post(other_user, %{status: "cofe", local_only: true})
with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
assert {:ok, %Activity{data: %{"type" => "Announce"}} = activity} =
CommonAPI.repeat(activity_id, user)
assert Activity.local_only?(activity)
refute called(Pleroma.Web.Federator.publish(activity))
end
end
test "unrepeat" do
user = insert(:user)
other_user = insert(:user)
{:ok, %Activity{id: activity_id}} =
CommonAPI.post(other_user, %{status: "cofe", local_only: true})
assert {:ok, _} = CommonAPI.repeat(activity_id, user)
with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
CommonAPI.unrepeat(activity_id, user)
assert Activity.local_only?(activity)
refute called(Pleroma.Web.Federator.publish(activity))
end
end
test "favorite" do
user = insert(:user)
other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", local_only: true})
with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
assert {:ok, %Activity{data: %{"type" => "Like"}} = activity} =
CommonAPI.favorite(user, activity.id)
assert Activity.local_only?(activity)
refute called(Pleroma.Web.Federator.publish(activity))
end
end
test "unfavorite" do
user = insert(:user)
other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", local_only: true})
{:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)
with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
assert {:ok, activity} = CommonAPI.unfavorite(activity.id, user)
assert Activity.local_only?(activity)
refute called(Pleroma.Web.Federator.publish(activity))
end
end
test "react_with_emoji" do
user = insert(:user)
other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", local_only: true})
with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
assert {:ok, %Activity{data: %{"type" => "EmojiReact"}} = activity} =
CommonAPI.react_with_emoji(activity.id, user, "👍")
assert Activity.local_only?(activity)
refute called(Pleroma.Web.Federator.publish(activity))
end
end
test "unreact_with_emoji" do
user = insert(:user)
other_user = insert(:user)
{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", local_only: true})
{:ok, _reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")
with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
CommonAPI.unreact_with_emoji(activity.id, user, "👍")
assert Activity.local_only?(activity)
refute called(Pleroma.Web.Federator.publish(activity))
end
end
end
end end

View file

@ -1740,4 +1740,23 @@ defmodule Pleroma.Web.MastodonAPI.StatusControllerTest do
|> get("/api/v1/statuses/#{activity.id}") |> get("/api/v1/statuses/#{activity.id}")
|> json_response_and_validate_schema(:ok) |> json_response_and_validate_schema(:ok)
end end
test "posting a local only status" do
%{user: _user, conn: conn} = oauth_access(["write:statuses"])
conn_one =
conn
|> put_req_header("content-type", "application/json")
|> post("/api/v1/statuses", %{
"status" => "cofe",
"local_only" => "true"
})
local = Pleroma.Web.base_url() <> "/#Public"
assert %{"content" => "cofe", "id" => id, "pleroma" => %{"local_only" => true}} =
json_response(conn_one, 200)
assert %Activity{id: ^id, data: %{"to" => [^local]}} = Activity.get_by_id(id)
end
end end

View file

@ -245,7 +245,8 @@ defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
direct_conversation_id: nil, direct_conversation_id: nil,
thread_muted: false, thread_muted: false,
emoji_reactions: [], emoji_reactions: [],
parent_visible: false parent_visible: false,
local_only: false
} }
} }